快速排序

算法：

快速排序是一种分治的排序算法。它将一个数组分成两个子数组，将两部分独立地排序。快速排序和归并排序是互补的；归并排序将数组分成两个子数组分别排序，并将有序的子数组归并以将整个数组排序；而快速排序将数组排序的方式则是当两个子数组都有序时整个数组也就自然有序了。在第一种情况中，递归调用发生在处理整个数组之前；在第二种情况中，递归调用发生在处理整个数组之后。在归并排序中，一个数组被等分为两半；在快速排序中，切分的位置取决于数组的内容。

复杂度：

将长度为N的无重复数组排序，快速排序平均需要2NlnN次比较（以及1/6的交换）。

快速排序最多需要约N^2/2次比较，但随机打乱数组能够预防这种情况。

不存在任何基于比较的排序算法能够在NH-N次比较之内将N个元素排序，其中H为由主键值出现频率定义的香农信息量。

对于大小为N的数组，三向切分的快速排序需要（2ln2）NH次比较。其中H为值出现频率定义的香农信息量。

代码：

public class Quick {

    public static void sort(Comparable[]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);
        sort(a,j+1,hi);
    }

    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;
            while (less(v,a[--j])) if(j==lo) break;
            if(i>=j) break;
            exch(a,i,j);

        }
        exch(a,lo,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++){
            System.out.println(a[i]+" ");
        }
    }
    private 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){
        Integer a[] ={1,5,3,2,6,8};

        sort(a);
        assert isSorted(a);
        show(a);
    }
}