289 ALGORITHM2.5 Quicksort

//快排是真的快，一百万的数字几秒钟就排好了

//解释都放到代码里的注释里去了

import edu.princeton.cs.algs4.*;

public class Quicksort
{
    public static void sort(Comparable[] a)
    {
        StdRandom.shuffle(a);//打乱数组a
        sort(a, 0, a.length - 1);
    }
    
    private static void sort(Comparable[] a, int lo, int hi)
    {
        if(hi <= lo)//递归退出的边界条件
            return;
        int j = partition(a, lo, hi);//找分割
        sort(a, lo, j-1);//递归,在分割点j左边继续找分割点
        sort(a, j+1, hi);//递归,在分割点j右边继续找分割点
    }
    
    private static int partition(Comparable[] a, int lo, int hi)//找分割点并把分割点放到最终位置上(也就是说分割点一旦归位就不会再移动了)
    {
        int i = lo, j = hi+1;
        Comparable v = a[lo];//把数组第一个元素作为分割点
        while(true)
        {
            while(less(a[++i], v)) if(i==hi) break;//找左边第一个大于分割点的数,if是防止恰好分割点就是最大值
            while(less(v,a[--j])) if(j==lo) break;//找右边第一个小于分割点的数,if是防止恰好分割点就是最小值
            if(i >= j) break;//找到分割点的最终位置时退出循环
            exch(a, i, j);//i不满足小于分割点,j也不满足大于分割点,所以交换他们两个就都满足条件了
        }
        exch(a, lo, j);//最终交换分割点和左边数组最后一个元素(因为是--j,所以最后判断条件不满足后j又减了一个,所以j在的位置就是左边数组最后一个了)
        return j;//返回分割点位置
    }
    
    private static boolean less(Comparable v, Comparable w)
    {
        return v.compareTo(w) < 0;
    }
    
    private static void exch(Comparable[] a, int i, int j)
    {
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
    
    private static void show(Comparable[] a)
    {
        for(int i = 0; i < a.length; i++)
            StdOut.print(a[i] + " ");
        StdOut.println();
    }
    
    public static boolean isSorted(Comparable[] a)
    {
        for(int i = 1; i < a.length; i++)
        {
            if(less(a[i], a[i-1]))
                return false;
        }
        return true;
    }
    
    public static void main(String[] args)
    {
        String[] a = In.readStrings();
        sort(a);
        assert isSorted(a);
        show(a);
    }
}