快速排序及三向切分快排——java实现

快速排序也是一种分治算法。主要思想是选取一个切分点，将大于切分点的元素都放置到数组右侧，小于切分点的元素都放置到数组左侧；然后递归，再对切分点左侧和右侧分别排序。

归并排序时递归在前，归并在后，快速排序是切分在前，排序在后。

快速排序的运行时间在1.39nlogn的某个常数因子范围之内，归并排序也能做到这一点，但是快速排序更快，因为它的移动次数更少。

快速排序的关键点在于切分点的选取，对于正好逆序的情况，它的复杂度达到了n²，而且与归并排序相比不稳定。

为了防止最坏情况的出现，一般在排序前先将元素随机打乱。

package 排序;

import edu.princeton.cs.algs4.In;
import edu.princeton.cs.algs4.StdOut;
import edu.princeton.cs.algs4.StdRandom;
/**
 * @author evasean www.cnblogs.com/evasean/
 */
@SuppressWarnings("rawtypes")
public class Quick快速排序 {
    private static int partition(Comparable[] a, int lo, int hi){
        int i = lo;
        int 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);//此时j<=i，且v > a[j]，将切分元素v放入正确位置
        return j;
    }
    public static void sort(Comparable[] a){
        StdRandom.shuffle(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);
    }
    
    @SuppressWarnings("unchecked")
    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 = new In().readAllStrings();
        sort(a);
        assert isSorted(a);
        show(a);
    }
}

实际应用中经常会出现大量重复元素的排序情况，而快速排序在面对重复元素时排序复杂度并没有降低。Dijkstra提出的三向切分快速排序方法可以迅速降低这种情况下的复杂度，甚至有可能达到线性级别n，如荷兰国旗问题（见我的另一篇文章）。其基本思想就是选取切分点v，从左到右遍历，维护一个从前往后遍历的位置点lt，使得a[0]~a[lt-1]都小于v，维护一个从前往后遍历的位置点i，使得a[lt]~a[i-1]都等于v，维护一个从后往前的位置点，使得a[i]~a[gt]都大于v。

/*
     * 三向切分的快速排序
     * a[lo...lt-1]中的元素都小于v
     * a[gt+1....hi]中的元素都大于v
     * a[lt...i-1]中的元素都等于v
     * a[i...gt]中的元素都还未确定,通过下面处理
     * 1. a[i]小于v，将a[lt]和a[i]交换，将lt和i加1
     * 2. a[i]大于v，将a[gt]和a[i]交换，将gt减1
     * 3. a[i]等于v，将i加1
     * 这些操作都会保证数组元素不变且缩小gt-i的值，这样循环才会结束
     */
    private static void sort3way(Comparable[] a, int lo, int hi){
        if(hi <= lo) return;
        int lt = lo;
        int i = lo+1;
        int gt = hi;
        Comparable v = a[lo];
        while(i <= gt){
            int cmp = a[i].compareTo(v);
            if(cmp<0) exch(a,lt++,i++);
            else if(cmp>0) exch(a,i,gt--);
            else i++;
        }//现在a[lo...lt-1] < v=a[lt...gt]<a[gt+1...hi]
        sort3way(a,lo,lt-1);
        sort3way(a,gt+1,hi);
    }

用这里的sort3way方法替代快速排序中的sort(Comparable[] a, int lo, int hi)即可。