快速排序（Quick Sort）

快速排序可以说是排序算法中速度最快的通用排序方法，只要是因为它的内循环中的指令很少。虽然在最差情况之下，其时间复杂度会达到平方级别，但可以通过在排序之前运用随机打乱数组的方法，避免最坏情况的出现。
其Java代码如下：

import edu.princeton.cs.algs4.StdOut;
import edu.princeton.cs.algs4.StdRandom;

public class Quick {

    public static void sort(Comparable[] a) {
        StdRandom.shuffle(a);
        int max = 0;
        /*
        for (int i = 0; i < a.length - 1; i++)
            if (a[max].compareTo(a[i]) < 0)
                max = i;
        exch(a, max, a.length - 1);
        */
        sort(a, 0, a.length - 1);
    }



     private static void sort(Comparable[] a, int lo, int hi) {
            if (lo >= hi)   return;
            int j = partition(a, lo, hi);
            sort(a, lo, j - 1);
            sort(a, j + 1, hi);
        }

     public 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; }
            while (less(a[++i], v))    { if (i == hi) break; }
            while (less(v, a[--j]))    {}
            if (i >= j) break;
            exch(a, i, j);
        }
        exch(a, lo, j);
        return j;
    }
     public static void sort3way(Comparable[] a, int lo, int hi) {
         if (lo >= hi) return;
         int i = lo + 1, gt = hi, lt = lo;
         Comparable v = a[lo];
         while (i <= gt) {
             int cmp = a[i].compareTo(v);
             if (cmp > 0)       exch(a, i, gt--);
             else if (cmp < 0)  exch(a, i++, lt++);
             else               i++;
         }
         sort3way(a, lo, lt - 1);
         sort3way(a, gt + 1, hi);       
    }
        private static boolean less(Comparable v, Comparable w) {
            if (v.compareTo(w) < 0) return true;
            else                     return false;
        }

        private static void exch(Comparable[] a, int i, int j) {
            Comparable temp = a[i];
                       a[i] = a[j];
                       a[j] = temp;
        }

        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 = 0; i < a.length - 1; i++) {
                if (!less(a[i], a[i + 1])) return false;
            }
            return true;
        }
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            Comparable[] a = {2, 3, 4, 1, 7, 8, 6, 5, 0, -10, 100,-11000};
            Quick.sort(a);
            //assert isSorted(a);
            show(a);
        }

}

其中其平均运行时间约为1.39NlogN, 虽然归并排序也能坐到这一点，但由于快速排序移动数据更少，因此快速排序往往做的更好。而且在序列中含有大量的重复元素时，运用经过改进的3-way quick sort可能将运行时间定格到线性。这些都是快排很重要的优点。但同时，快排不是一种稳定排序算法，而且在对小序列进行排序时，它的效果不如插入排序。Java内置的排序算法，对于原始变量等，采用快排；对于对象等其他变量，则采用归并排序。