快速排序的五种优化（高频面试）

快速排序的五种优化（高频面试）

未优化

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 ;
}

单边递归法

单边递归法 quick_sort_v2
单边递归法将一侧交给递归函数实现，另一侧交给本层函数实现

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 ;
}

无监督算法

基准值左侧和基准值右侧不符合快速排序规定的元素数目必定相等
以此分别在左右部分找到不符合规定元素之后进行交换

void quick_sort_v3(int *arr, int l, int r) {
    while (l < r) {
        int x = l, y = r, z = arr[l];
        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_v3(arr, l, y);
        l = x;
    }
    return ;
}

对小区间使用插入排序

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 ;
}

/*
	对小区间使用插入排序 quick_sort_v4
*/

void quick_sort_v4(int *arr, int l, int r) {
    while (r - l >= 16) {
        int x = l, y = r, z = arr[l];
        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 ;
}

随机选取基准值

void quick_sort_v5(int *arr, int l, int r) {
    while (l < r) {
        int x = l, y = r, z = arr[l + rand() % (r - l + 1)];
        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_v5(arr, l, y);
        l = x;
    }
    return ;
}

三点取中法

三点取中法 quick_sort_v6
引入middle函数取中间值，相比随机选取更稳定一些

inline int middle(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 (a > c) swap(a, c);
    if (b > c) swap(b, c);
    return b;
}

void quick_sort_v6(int *arr, int l, int r) {
    while (l < r) {
        int x = l, y = r, z = middle(arr, l, r);
        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;
    }
    return ;
}