快速排序（Quick Sort）介绍

原理介绍

快速排序是分治法（Divide and Conquer）的典型应用，基本思想是在数组中适当的轴心（partition），然后将数组一分为二，再分别对左边和右边数组进行排序，而影响快速排序法效率的正是轴心的选择。
快速排序根据分割点的不同，有三种版本：
选择最左端的数为比较对象，低指针从左边开始向右移动，高指针从右边开始向左移动；
选择中间的数为比较对象，低指针从左边开始向右移动，高指针从右边开始向左移动；
选择最右端的数为比较对象，低指针和高指针都从左端开始移动。

快排的三种版本

下面分别介绍三种快速排序的版本。
第一种版本：
（1）将最左边的数设定为轴，其值为val
循环：
（2）令索引i 从数组左方往右方找，直到找到大于 val 的数
（3）令索引 j 从数组右方往左方找，直到找到小于 val 的数
（4）如果 i >= j，则离开循环，否则，交换索引 i 与 j 两处的值
（5）将左侧的轴与 j 进行交换
（6）对轴左边（j-1）的数组进行递归处理
（7）对轴右边（j+1）的数组进行递归处理

public static void QuickSort(int[] a, int lo, int hi)
{
if (lo >= hi) return;
int i = lo;
int j = hi + 1;

while (true)
{
while ((a[++i] < a[lo]))
if (i == hi) break;
while ((a[--j] > a[lo]))
if (j == lo) break;
if (i >= j) break;
exch(a, i, j);
}
exch(a, lo, j);

QuickSort(a, lo, j-1);
QuickSort(a, j+1, hi);
}

第二种版本：
（1）将中间的数val设为轴
循环：
（2）令索引i 从数组左方往右方找，直到找到大于 val 的数
（3）令索引 j 从数组右方往左方找，直到找到小于 val 的数
（4）如果 i >= j ，则离开循环，否则，交换索引 i 与 j 两处的值
（5）对轴左边（i-1）的数组进行递归处理
（6）对轴右边（j+1）的数组进行递归处理
边界正确性证明：
（1）若 i == j ，则 i-1 和 j+1 正好是某个数两边的界限
（2）若 i > j ，则不难知道 i-1 == j （即 i == j+1），则 i-1 与 j+1 正好是两个子数组的边界

public static void QuickSort (int[] a, int lo, int hi)
{
if (lo >= hi) return;
int i = lo-1, j = hi+1;
int mid = (lo + hi) / 2;
int val = a[mid];

while (true)
{
while (a[++i] < val)
if (i == hi) break;
while (a[--j] > val)
if (j == lo) break;
if (i >= j) break;
exch(a, i, j);
}

QuickSort(a, lo, j);
QuickSort(a, j+1, hi);
}

第三种版本：
（1）将最右边的数 val 设为轴
循环：

（2）令索引 j 从数组左方开始往右方找，直到找到小于 val的数
（3）若 j 小于高位hi ，则交换 i 和 j 位置的元素，然后 i++
（4）若j
大于或等于高位hi ，则退出循环



（5）交换 i位置的数和最右边的数



（6）对 i-1 左边的数组进行递归排序
（7）对i+1 右边的数组进行递归排序

public static void QuickSort (int[] a, int lo, int hi)
{
if (lo >= hi) return;
int i = lo, j = lo-1;
int val = a[hi];

while (true)
{
while (a[++j] >= val)
if (j == hi) break;
if (j >= hi) break;
exch(a, i++, j);
}
exch(a, i, hi);

QuickSort(a, lo, i-1);
QuickSort(a, i+1, hi);
}

含有重复键（duplicate key）的快排程序

若序列中含有大量重复键，若使用前面三种方法进行排序，会使得重复键参与到下一次排序中，极大地降低了排序算法的效率。Robert Sedgewick 提出了一种方法，使得重复键不参与下一次的排序中，提升了算法的效率。不过键交换的次数会增多。
算法的步骤如下：
（1）设定三个指针分别为lt，i，gt。其中，在指针lt左边的数组值小于val，在lt到i之间的数组值等于val，在gt右边的数组值大于val，在i到gt之间的值是未处理的。







循环（i <= gt时）：
（2）当索引i处的值小于val时，交换i 和lt的值
（3）当索引i处的值大于val时，交换i 和gt的值
（4）否则（当索引i处的值等于val时），i自增
（5）对lt左边的数组进行排序
（6）对gt右边的数组进行排序

public static void QuickSort_DuplicateKeys(int[] a, int lo, int hi)
{
if (lo >= hi) return;
int lt = lo, gt = hi;
int i = lt;
int val = a[lo];

while (i <= gt)
{
if (a[i] < val)
exch(a, i++, lt++);
else if (a[i] > val)
exch(a, i, gt--);
else i++;
}

QuickSort_DuplicateKeys(a, lo, lt-1);
QuickSort_DuplicateKeys(a, gt+1, hi);
}

快排的特性

1.快排是一种内排序算法
2.快排时间复杂度的最好情况是~NlgN，最坏情况是~(1/2)*N^2，平均情况是~1.39NlgN
3.快排的空间复杂度：对于Partitioning：需要常数级的额外空间；对于递归的深度：需要对数级的额外空间

快排的优化

1.在JDK API的数组排序算法中，会先对数组的长度进行判断。若是长度较短的数组，则直接使用插入排序。对于较长的数组才使用快速排序。
2.Robert Sedgewick认为在快速排序之前，应先对数组进行Shuffle操作，以提高快速排序的性能。因为在最坏的情况下，快排的时间复杂度是~(1/2)*N^2。而平均情况下，快排的时间复杂度是~1.39NlgN。