快速排序的基础与优化

基础的快速排序

​ 先从最基础的快速排序思想开始，选中左边第一个数为基点，将小于该基点的节点放到左边，大于基点的节点放到右边，基点放在中间，然后对两边的子序列递归调用。

• 代码实现

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库中的排序采用了此方法。