深入理解 快速排序 之三路划分算法

深入理解快速排序之三路划分算法

一、排序算法概述

在计算机科学领域，排序算法是基础且至关重要的一部分。排序算法用于将一组数据按照特定顺序（如升序或降序）进行排列。不同的排序算法在时间复杂度、空间复杂度、稳定性等方面存在差异，以适应不同的应用场景。

快速排序（Quick Sort）是一种分治算法，由托尼・霍尔在 1960 年提出。它通常具有较高的效率，平均时间复杂度为 \(O(n log n)\)，在实际应用中被广泛使用。然而，传统的快速排序在处理包含大量重复元素的数组时，性能会有所下降。为了解决这个问题，三路划分的快速排序应运而生。

二、传统快速排序的局限性

传统的快速排序算法在每一轮划分过程中，选择一个基准元素（pivot），然后将数组分为两部分：小于基准元素的部分和大于等于基准元素的部分。这个过程通过两个指针从数组的两端向中间移动，不断交换元素的位置来实现。

但是，当数组中存在大量重复元素时，传统快速排序会进行很多不必要的交换操作。例如，对于一个包含大量相同元素的数组，每次划分时，相同的元素会被反复交换，导致算法的效率降低。

三、快速排序三路划分的原理

三路划分的快速排序算法将数组划分为三个部分：小于基准元素的部分、等于基准元素的部分和大于基准元素的部分。这样做的好处是，在处理包含大量重复元素的数组时，能够避免不必要的交换操作，从而提高算法的效率。

具体步骤如下：

1. 选择基准元素：从数组中随机选择一个元素作为基准元素（pivot）。
2. 划分过程：遍历数组，将元素分为三个区域：
   • 小于基准元素的区域：位于数组的左侧。
   • 等于基准元素的区域：位于小于基准元素区域的右侧。
   • 大于基准元素的区域：位于数组的右侧。
3. 递归排序：对小于基准元素的区域和大于基准元素的区域分别进行递归排序。

 

代码思路：

1. key默认取left位置的值。

2. left指向区间最左边，right指向区间最后边，cur指向left+1位置。

3. cur遇到⽐key⼩的值后跟left位置交换，换到左边，left++，cur++。

4. cur遇到⽐key⼤的值后跟right位置交换，换到右边，right--。

5. cur遇到跟key相等的值后，cur++。

6. 直到cur > right结束

四、代码实现及详细解释

代码示例

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>

// 交换两个整数的值
void swap(int* x, int* y) {
    int tmp = *x;
    *x = *y;
    *y = tmp;
}

// 快排三路划分
void QuickSort(int* a, int left, int right) {
    if (left >= right) {
        return;
    }
    int begin = left;
    int end = right;
    // 随机选key
    int randi = left + (rand() % (right - left + 1));
    swap(&a[left], &a[randi]);

    int key = a[left];
    int cur = left + 1;
    while (cur <= right) {
        if (a[cur] < key) {
            swap(&a[cur], &a[left]);
            ++left;
            ++cur;
        }
        else if (a[cur] > key) {
            swap(&a[cur], &a[right]);
            --right;
        }
        else {
            ++cur;
        }
    }
    // [begin, left - 1] [left, right] [right + 1, end]
    QuickSort(a, begin, left - 1);
    QuickSort(a, right + 1, end);
}

// 打印数组元素
void printArray(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main() {
    int arr[] = {10, 7, 8, 9, 1, 5};
    int n = sizeof(arr) / sizeof(arr[0]);

    printf("排序前的数组: \n");
    printArray(arr, n);

    QuickSort(arr, 0, n - 1);

    printf("排序后的数组: \n");
    printArray(arr, n);

    return 0;
}

函数详细解释

1. swap 函数

void swap(int* x, int* y) {
    int tmp = *x;
    *x = *y;
    *y = tmp;
}

• 功能：交换两个整数的值。
• 参数：
  • x：指向第一个整数的指针。
  • y：指向第二个整数的指针。
• 实现细节：
  • 首先，使用一个临时变量 tmp 来保存 *x 的值。这是因为在后续的赋值操作中，*x 的值会被覆盖，如果不保存，就会丢失原始值。
  • 然后，将 *y 的值赋给 *x。
  • 最后，将 tmp 的值赋给 *y，完成交换操作。

2. QuickSort 函数

void QuickSort(int* a, int left, int right) {
    if (left >= right) {
        return;
    }
    int begin = left;
    int end = right;
    // 随机选key
    int randi = left + (rand() % (right - left + 1));
    swap(&a[left], &a[randi]);

    int key = a[left];
    int cur = left + 1;
    while (cur <= right) {
        if (a[cur] < key) {
            swap(&a[cur], &a[left]);
            ++left;
            ++cur;
        }
        else if (a[cur] > key) {
            swap(&a[cur], &a[right]);
            --right;
        }
        else {
            ++cur;
        }
    }
    // [begin, left - 1] [left, right] [right + 1, end]
    QuickSort(a, begin, left - 1);
    QuickSort(a, right + 1, end);
}

• 功能：实现快速排序的三路划分算法。
• 参数：
  • a：指向待排序数组的指针。
  • left：当前子数组的左边界。
  • right：当前子数组的右边界。
• 实现步骤：
  1. 递归终止条件：
     • 如果 left >= right，说明当前子数组只有一个元素或为空，不需要进行排序，直接返回。
  2. 选择基准元素：
     • 使用 rand() 函数随机选择一个元素的索引 randi，范围在 [left, right] 之间。
     • 调用 swap 函数将随机选择的元素与数组的左边界元素交换，这样基准元素就位于数组的左边界。
  3. 初始化变量：
     • key 保存基准元素的值。
     • cur 指针从左边界的下一个位置开始遍历数组。
  4. 划分过程：
     • 使用 while 循环遍历数组，直到 cur 指针超过右边界。
     • 如果 a[cur] < key，说明当前元素小于基准元素，将其与 a[left] 交换，并将 left 和 cur 指针右移。
     • 如果 a[cur] > key，说明当前元素大于基准元素，将其与 a[right] 交换，并将 right 指针左移。注意，此时 cur 指针不移动，因为交换后 a[cur] 是一个新的元素，需要重新判断。
     • 如果 a[cur] == key，说明当前元素等于基准元素，直接将 cur 指针右移。
  5. 递归排序：
     • 划分完成后，数组被分为三个部分：[begin, left - 1] 是小于基准元素的部分，[left, right] 是等于基准元素的部分，[right + 1, end] 是大于基准元素的部分。
     • 对小于基准元素的部分和大于基准元素的部分分别进行递归排序。

3. printArray 函数

void printArray(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

• 功能：打印数组的所有元素。
• 参数：
  • arr：指向数组的指针。
  • size：数组的大小。
• 实现细节：
  • 使用 for 循环遍历数组，从索引 0 到 size - 1。
  • 使用 printf 函数打印每个元素，并在元素之间添加一个空格。
  • 遍历结束后，使用 printf("\n") 换行。

4. main 函数

int main() {
    int arr[] = {10, 7, 8, 9, 1, 5};
    int n = sizeof(arr) / sizeof(arr[0]);

    printf("排序前的数组: \n");
    printArray(arr, n);

    QuickSort(arr, 0, n - 1);

    printf("排序后的数组: \n");
    printArray(arr, n);

    return 0;
}

• 功能：程序的入口点，用于测试快速排序的三路划分算法。
• 实现步骤：
  1. 定义一个测试数组 arr，并使用 sizeof 运算符计算数组的大小 n。
  2. 调用 printArray 函数打印排序前的数组。
  3. 调用 QuickSort 函数对数组进行排序，左边界为 0，右边界为 n - 1。
  4. 调用 printArray 函数打印排序后的数组。

五、复杂度分析

• 时间复杂度：平均情况下，三路划分的快速排序算法的时间复杂度为 \(O(n log n)\)。在处理包含大量重复元素的数组时，其性能优于传统的快速排序。最坏情况下，时间复杂度为 \(O(n^2)\)，例如当数组已经有序时。
• 空间复杂度：主要由递归调用栈的深度决定，平均情况下为 \(O(log n)\)，最坏情况下为 \(O(n)\)。

六、总结

快速排序的三路划分算法通过将数组划分为三个部分，有效地处理了包含大量重复元素的数组，避免了不必要的交换操作，提高了算法的效率。该算法在实际应用中具有重要的价值，尤其是在处理大规模数据时。

通过本文的详细介绍，你应该对快速排序的三路划分算法有了更深入的理解。如果你在实际应用中遇到相关问题，可以根据具体情况选择合适的排序算法。

希望本文能对你有所帮助！如果你有任何疑问或建议，欢迎在评论区留言。