——————算法原理——————
快速排序算法一种最常见的排序算法，其核心思想就是 分治 ，具体的：
（1） 选定一个基准数；
（2） 分区，将所有大于基准数的数据分为一区，将所有小于等于基准数的数据分为一区；
（3） 递归，对上述分区重复(1)(2)，直到每个分区只有一个数。
———————————————————————————
下面看一个动画来快速理解该算法是怎么工作的：
—————————— 算法实现 ——————————
由原理部分我们也可以先推测一下，实现算法的关键点应该和基准数的选取以及分区的存储有关。
根据分区方法的不同，通常有两种处理策略：
一种称之为Lomuto 分区策略：
先上伪代码：
// 递归
quicksort(A, low, high)
if low < high then
// 找到新的分区点
p = partition(A, low, high)
quicksort(A, low, p – 1)
quicksort(A, p + 1, high)
// 分区
algorithm partition(A, low, high) is
// 选定最后一个元素为基准数
pivot := A[high]
// 记录交换位置
i := low
for j := low to high – 1 do
if A[j] ≤ pivot then
swap A[i] with A[j]
i := i + 1
swap A[i] with A[hi]
return i
// 函数调用
quicksort(A, 0, length(A)-1)我们先举一个例子来理解上面的代码，由于是递归过程，我们只需要搞清楚一次分区是如何进行的就可以了。
下面给出C++的测试代码:
#include<iostream>
// 子函数：交换两个数据
void swap(int* a, int* b)
{
int t = *a;
*a = *b;
*b = t;
}
// 子函数：数据分区，返回分区点，使得分区点左边的数据不大于分区点数据，同时分区点右边数据大于分区点数据
int partition (int arr[], int low, int high)
{
int pivot = arr[high]; // 选择基准数为最后一个元素
int i = low; // 记录待交换位置
for (int j = low; j <= high- 1; j++)
{
// 如果小于等于基准数
if (arr[j] <= pivot)
{
swap(&arr[i], &arr[j]);
i++; // 交换位置++
}
}
swap(&arr[i], &arr[high]);
return i;
}
// 快排主函数
void quickSort(int arr[], int low, int high)
{
if (low < high)
{
// 记录新的分区点
int pi = partition(arr, low, high);
// 分别处理前后两个分区
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}
// 打印数组
void printArray(int arr[], int size)
{
int i;
for (i=0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}
// 主函数
int main()
{
int arr[] = {3, 7, 8, 5, 2, 4};
quickSort(arr, 0, 5);
printf("Sorted array: \n");
printArray(arr, 6);
return 0;
}还有一种称之为 Hoare 的分区策略，伪代码如下:
algorithm quicksort(A, lo, hi) is
if lo < hi then
p := partition(A, lo, hi)
quicksort(A, lo, p)
quicksort(A, p + 1, hi)
algorithm partition(A, lo, hi) is
// 选定第一个元素为基准数
pivot := A[lo]
i := lo - 1
j := hi + 1
loop forever
do
i := i + 1
while A[i] < pivot
do
j := j - 1
while A[j] > pivot
if i >= j then
return j
// 分别找到一个大于和小于基准数的数值并交换
swap A[i] with A[j]相比Lomuto 策略，Hoare 策略需要交换的次数更少，同时可以较好的处理所有数值都相等的情况。但当数据已经有序时，Hoare 策略导致复杂度退化到O(n^2)。
—————————— 如何选择基准数 ——————————
(1) 选择固定的基准
比如上面我们的示例代码，要么选择最左边作为基准要么选择最右边。如果数组已经有序排列，那么这种选择方法将会导致复杂度退化到O(n^2)。
(2) 随机选择基准
虽然可以比较好的解决上面的问题，但随机数的生成往往代价不菲。
(3) 三数取中
事实上，选择中位数是一个不错的策略，但问题是计算中位数同样代价不菲。 退而求其次，左我们选择左端、右端和中心位置上的三个元素的中值作为“基准”。
随机选择的复杂度约为 \(1.386 n \log n\)，三数取中的平均复杂度约为\(1.188 n \log n\)。此外，当数据量较大时，三数取中的方法可以有更好的替代策略：
\(ninther(a) = median(Mo3(first \ 1/3 \ of \ a), Mo3(middle \ 1/3\ of\ a), Mo3(final \ 1/3 \ of \ a))\)
同时，当数据量较大时，计算 \((lo + hi)/2\) 可能发生数值溢出，正确的处理方式是 \(lo + (hi−lo)/2\).
—————————— 如何处理重复数据 ——————————
最极端的情况就是数组里面的所有元素都是相等的，这个时候前面的划分为 “小于等于”和“大于”两个区的处理方式就非常低效。 这里有一种简单的线性处理策略：将数据分为三组：小于、等于、大于。
伪代码也很简单，原来只返回一个划分索引，现在要返回两个索引(小于的边界索引、大于的边界索引)：
algorithm quicksort(A, lo, hi) is
if lo < hi then
p := pivot(A, lo, hi)
left, right := partition(A, p, lo, hi) // note: multiple return values
quicksort(A, lo, left - 1)
quicksort(A, right + 1, hi)参考链接：
