快速排序及三向切分快排——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)即可。