基础的快速排序
先从最基础的快速排序思想开始,选中左边第一个数为基点,将小于该基点的节点放到左边,大于基点的节点放到右边,基点放在中间,然后对两边的子序列递归调用。
- 代码实现
void quick_sort_v1(int *arr, int l, int r) {
if (l >= r) return ;
int x = l, y = r, z = arr[l];
while (x < y) {
while (x < y && arr[y] >= z) --y;
if (x < y) arr[x++] = arr[y];
while (x < y && arr[x] <= z) ++x;
if (x < y) arr[y--] = arr[x];
}
arr[x] = z;
quick_sort_v1(arr, l, x - 1);
quick_sort_v1(arr, x + 1, r);
return ;
}
单边递归法优化
快速排序是一种递归算法,因此可以画出递归树。因为要分别对左子序列和右子序列进行递归,所以是一个二叉递归树。单边递归算法就是将其中一半的递归在本层进行,另一半才继续向下递归。比如,对右子序列进行递归,但对于左子序列我们仅通过修改序列的左界限,在本层递归完成。
- 代码实现
void quick_sort_v2(int *arr, int l, int r) {
while (l < r) {
int x = l, y = r, z = arr[l];
while (x < y) {
while (x < y && arr[y] >= z) --y;
if (x < y) arr[x++] = arr[y];
while (x < y && arr[x] <= z) ++x;
if (x < y) arr[y--] = arr[x];
}
arr[x] = z;
quick_sort_v2(arr, l, x - 1);
l = x + 1;
}
return ;
}
无监督Partition优化
上述几种方法中,
while (x < y && arr[y] >= z)
这样的语句中,对于x < y
的监督会造成大量时间开销,因此采用无监督Partition优化法可以减少运行时间。具体实现是让序列两头的指针同时向中间移动,左边的指针遇到大于基点的数就停下,右边的指针遇到小于基点的数就停下,然后将这两个数进行交换,直到指针重合后,继续使用单边递归法。
- 代码实现
#include <algorithm>
void quick_sort_v3(int *arr, int l, int r) {
while (l < r) {
int x = l, y = r, z = arr[l], temp;
do {
while (arr[x] < z) x++;
while (arr[y] > z) y--;
if (x <= y) {
temp = arr[x], arr[x] = arr[y], arr[y] = temp;
x++, y--;
}
} while (x <= y);
quick_sort_v3(arr, l, y);
l = x;
}
return ;
}
小范围使用插入排序
当面对的要排序的区间比较小(一般是小于16个数时),不必要使用快速排序,因此可以将小于16个数的区间替换为其他排序算法,如插入排序。
- 代码实现
#include <algorithm>
#define swap(a, b) { \
__typeof(a) temp = a; \
a = b, b = temp; \
}
static void unguarded_insert_sort(int *arr, int l, int r) {
int ind = l;
for (int i = l + 1; i <= r; i++) {
if (arr[i] < arr[ind]) ind = i;
}
swap(arr[l], arr[ind]);
for (int i = l + 2; i <= r; i++) {
int j = i;
while (arr[j] < arr[j - 1]) {
swap(arr[j], arr[j - 1]);
--j;
}
}
return ;
}
void quick_sort_v4(int *arr, int l, int r) {
while (r - l >= 16) {
int x = l, y = r, z = arr[l], temp;
do {
while (arr[x] < z) x++;
while (arr[y] > z) y--;
if (x <= y) {
swap(arr[x], arr[y]);
x++, y--;
}
} while (x <= y);
quick_sort_v4(arr, l, y);
l = x;
}
if (l < r) unguarded_insert_sort(arr, l, r);
return ;
}
#undef swap
三点取中法
基准点的选取决定了快速排序的效果,若基准点选得不好,时间复杂度会达到O(n^2), 最好的情况是每次选的基准值都是中位数。我们可以通过用随机选取基准点的方法来替换原来的选取第一个数,不过这样具有一定的不稳定性。另一个较为稳定的方法是
三点取中法
。每次选取头、中、尾部的数,选取三者中间值作为基准值来进行快速排序。
- 代码实现
#include <algorithm>
#define swap(a, b) { \
__typeof(a) temp = a; \
a = b, b = temp; \
}
static void unguarded_insert_sort(int *arr, int l, int r) {
int ind = l;
for (int i = l + 1; i <= r; i++) {
if (arr[i] < arr[ind]) ind = i;
}
swap(arr[l], arr[ind]);
for (int i = l + 2; i <= r; i++) {
int j = i;
while (arr[j] < arr[j - 1]) {
swap(arr[j], arr[j - 1]);
--j;
}
}
return ;
}
static inline int median_number(int *arr, int l, int r) {
int a = arr[l], b = arr[r], c = arr[(l + r) >> 1];
if (a > b) swap(a, b);
if (b > c) swap(b, c);
if (a > b) swap(a, b);
return b;
}
void quick_sort_v6(int *arr, int l, int r) {
while (r - l >= 16) {
int x = l, y = r, z = median_number(arr, l, r), temp;
do {
while (arr[x] < z) x++;
while (arr[y] > z) y--;
if (x <= y) {
swap(arr[x], arr[y]);
x++, y--;
}
} while (x <= y);
quick_sort_v6(arr, l, y);
l = x;
}
if (l < r) unguarded_insert_sort(arr, l, r);
return ;
}
#undef swap
STL-sort
当快速排序达到一定的递归层数阈值时,改用堆排序进行后续的排序。C++ STL库中的排序采用了此方法。