快速排序

快速排序算法是一种分治的排序算法。将一个数组分成两个子数组，将两部分独立的排序。
在快速排序中，递归调用发生在数组处理之后，且切分的位置取决于数组内容。

Java版代码：

public class Quick
{
    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);
    }

    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;
}

该方法关键在于切分：
a[j]已排定
a[lo]到a[j-1]中所有元素都不大于a[j]
a[j+1]到a[hi]中所有元素都不小于a[j]

Python版代码：

def quick_sort(lst):
    qsort_rec(lst, 0, len(lst) - 1)

def qsort_rec(lst, l, r):
    if l >= r:
        return
    i = l
    j = r
    pivot = lst[i]
    while i < j:
        while i < j and lst[j].key >= pivot.key:
            j -=1
        if i < j:
            lst[i] = lst[j]
            i += 1
        while i < j and lst[i].key <= pivot.key:
            i += 1
        if i < j:
            lst[j] = lst[i]
            j -= 1
        lst[i] = pivot
        qsort_rec(lst, l, i-1)
        qsort_rec(lst, i+1, r)