快速排序的基础与优化

基础的快速排序

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

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

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值