排序-快速排序

package test;

/*
 * 快速排序  在最坏情况下是O(N^2)，平均的时间复杂度是O(N*logN)  不稳定
 * 算法稳定性 -- 假设在数列中存在a[i]=a[j]，若在排序之前，a[i]在a[j]前面；
 * 并且排序之后，a[i]仍然在a[j]前面。则这个排序算法是稳定的！
 * 快速排序采用的思想是分治思想。
 * 快速排序是找出一个元素（理论上可以随便找一个）作为
 * 基准(pivot),然后对数组进行分区操作,使基准左边元素的值都不大于基准值,
 * 基准右边的元素值 都不小于基准值，如此作为基准的元素调整到排序后的正确位置。
 * 递归快速排序，将其他n-1个元素也调整到排序后的正确位置。最后每个元素都是在
 * 排序后的正确位置，排序完成。所以快速排序算法的核心算法是分区操作，
 * 即如何调整基准的位置以及调整返回基准的最终位置以便分治递归。
 */
public class QuickSort {
    public static void sort(int[] a) {
        sort(a,0,a.length-1);
    }
    private static void sort(int[] a,int low,int high) {
        if(low >= high) {
            return;
        }
        int j = partition(a,low,high);
        sort(a,low,j-1);
        sort(a,j+1,high);
    }
    //寻找切分元素索引
    private static int partition(int[] a,int low,int high) {
        int i = low;
        int j = high + 1;
        //取a[low]为基准元素
        int temp = a[low];
        while(true) {
            //i的左边不大于切分元素
            while(a[++i]<temp) {
                //注意索引是否越界
                if(i == high)
                    break;
            }
            //j的右边不小于切分元素
            while(a[--j]>temp) {}
            //当i与j相遇时，遍历完low和high之间的元素，
            //a[i]>=temp,a[j]<=temp;此时退出
            if(i>=j)
                break;
            //当i<j时，未遍历完low和high之间的元素，
            //a[i]>=temp,a[j]<=temp;此时交换
            swap(a,i,j);
        }
        //将切分元素放在正确位置
        swap(a,low,j);
        return j;
    }
    private static void swap(int[] a,int i,int j) {
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
    public static void main(String[] args) {
        int[] a = new int[100];
        for(int i=0;i<a.length;i++) {
            a[i] = (int)(Math.random()*100);
        }
        sort(a);
        int n = 0; 
        for(int i:a) {
            System.out.print(i+" ");
            n++;
            if(n==20) {
                n = 0;
                System.out.println();
            }
                
        }
    }
}