快速排序

算法描述

1. 每一轮排序选择一个基准点（pivot）进行分区

   1. 让小于基准点的元素的进入一个分区，大于基准点的元素的进入另一个分区
   2. 当分区完成时，基准点元素的位置就是其最终位置

2. 在子分区内重复以上过程，直至子分区元素个数少于等于 1，这体现的是分而治之的思想

3. 从以上描述可以看出，一个关键在于分区算法，常见的有洛穆托分区方案、双边循环分区方案、霍尔分区方案

单边快排

单边循环快排分区规则如下：

• 1.选取最右侧元素为基准点
• 2.指针：i.分区指示器 j. 迭代指针
• 3.i维护小于基准点的边界，j负责查找小于基准点的数
• 4.查到小于基准点时则i于j交换
• 5.最后基准点元素与分区（i）交换。

代码如下：

public int partitionOne(int[] a , int l , int r){
    int pv = a[r];
    int i = l; 
    for (int j = l; j < r; j++) {
        if(a[j] < pv){
            swap(a,j,i);
            i++;
        }
    }
    if(i != r){
        swap(a,i,r);
    }
    return i;//最后返回分割点。
}
public static void quick(int[] a,int l , int r){
    if(l >= r) {
        return;//当左边界大于等于右边界时结束
    }
    int p = partition(a,l,r);
    quick(a,l,p-1);
    quick(a,p+1,r);
}
private static void swap(int[] a, int i, int j) {
    int temp = a[i];
    a[i] = a[j];
    a[j] = temp;
}

双边循环快排（不完全等价于 hoare 霍尔分区方案）

1. 选择最左元素作为基准点元素
2. j 指针负责从右向左找比基准点小的元素，i 指针负责从左向右找比基准点大的元素，一旦找到二者交换，直至 i，j 相交
3. 最后基准点与 i（此时 i 与 j 相等）交换，i 即为分区位置

要点

1. 基准点在左边，并且要先 j 后 i
2. while( i < j && a[j] > pv ) j--
3. while ( i < j && a[i] <= pv ) i++

private static void quick(int[] a, int l, int h) {
    if (l >= h) {
        return;
    }
    int p = partition(a, l, h);
    quick(a, l, p - 1);
    quick(a, p + 1, h);
}

private static int partition(int[] a, int l, int h) {
    int pv = a[l];
    int i = l;
    int j = h;
    while (i < j) {
        // j 从右找小的
        while (i < j && a[j] > pv) {
            j--;
        }
        // i 从左找大的
        while (i < j && a[i] <= pv) {
            i++;
        }
        swap(a, i, j);
    }
    swap(a, l, j);
    System.out.println(Arrays.toString(a) + " j=" + j);
    return j;
}

快排特点

0. 平均时间复杂度是 $O(nlog_2⁡n )$，最坏时间复杂度 $O(n^2)$
1. 数据量较大时，优势非常明显
2. 属于不稳定排序

洛穆托分区方案 vs 霍尔分区方案

• 霍尔的移动次数平均来讲比洛穆托少3倍
• qastack.cn/cs/11458/qu…

最后需要页面演示的HTML代码