高级排序算法(一):快速排序详解

引言

当我们处理大规模数据时,像冒泡排序、选择排序这样的基础排序算法就有点力不从心了。这时候,快速排序(Quick Sort)就派上用场了。
作为一种基于
分治法
的高效排序算法,快速排序在大多数情况下可以在**O(n log n)**的时间内完成排序。它不仅理论上效率高,而且在实际应用中表现也非常优异,是排序算法中的经典之作。

这篇文章将带你深入理解快速排序的原理、实现细节以及优化策略。


一、快速排序的核心思想

快速排序的核心是分治法(Divide and Conquer),它将问题分为更小的子问题逐一解决。快速排序的主要步骤如下:

  1. 选择一个基准值(Pivot):通常选取数组中的一个元素作为基准。
  2. 分区
    • 将小于基准值的元素放到左侧。
    • 将大于基准值的元素放到右侧。
  3. 递归排序
    • 对左右两个部分分别递归地应用快速排序。

二、快速排序的分区方法

分区是快速排序的核心操作,它直接决定了算法的性能。常见的分区方法有两种:

1. Lomuto分区法
  • 选取数组的最后一个元素作为基准值。
  • 使用一个指针i将数组分为两部分:
    • 左侧:小于基准值的元素。
    • 右侧:大于基准值的元素。
  • 最后将基准值放到正确的位置。
cpp 复制代码
​
int lomutoPartition(int arr[], int low, int high) {
    int pivot = arr[high];  // 基准值
    int i = low - 1;        // 指针 i 初始化在 low 的前面

    for (int j = low; j < high; j++) {
        if (arr[j] < pivot) {  // 如果当前元素小于基准值
            i++;
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;  // 交换 i 和 j 的元素
        }
    }
    // 将基准值放到正确的位置
    int temp = arr[i + 1];
    arr[i + 1] = arr[high];
    arr[high] = temp;
    return i + 1;  // 返回基准值的索引
}

​
2. Hoare分区法
  • 使用两个指针:
    • 左指针i从左向右移动,找到第一个大于基准值的元素。
    • 右指针j从右向左移动,找到第一个小于基准值的元素。
  • 交换ij的元素,直到两个指针相遇。
  • 与Lomuto相比,Hoare分区法交换次数更少,适合大规模数据。
cpp 复制代码
​
int hoarePartition(int arr[], int low, int high) {
    int pivot = arr[low];  // 基准值
    int i = low - 1;
    int j = high + 1;

    while (1) {
        do {
            i++;
        } while (arr[i] < pivot);  // 从左向右找到大于等于 pivot 的元素

        do {
            j--;
        } while (arr[j] > pivot);  // 从右向左找到小于等于 pivot 的元素

        if (i >= j) return j;  // 指针相遇,返回分区点

        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;  // 交换 i 和 j 的元素
    }
}

​

三、快速排序的完整实现

以下是快速排序的完整实现,使用Lomuto分区法。

cpp 复制代码
​
#include <stdio.h>

// Lomuto 分区法
int partition(int arr[], int low, int high) {
    int pivot = arr[high];
    int i = low - 1;

    for (int j = low; j < high; j++) {
        if (arr[j] < pivot) {
            i++;
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
    int temp = arr[i + 1];
    arr[i + 1] = arr[high];
    arr[high] = temp;
    return i + 1;
}

// 快速排序
void quickSort(int arr[], int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);  // 分区点
        quickSort(arr, low, pi - 1);         // 排序左部分
        quickSort(arr, pi + 1, high);        // 排序右部分
    }
}

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

    quickSort(arr, 0, n - 1);

    printf("排序后的数组: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

​

四、快速排序的时间复杂度

快速排序的时间复杂度取决于分区点的选择:

  • 最优情况 :每次分区将数组均分为两部分,时间复杂度为 O(n log n)
  • 最坏情况 :每次分区只分出一个元素,时间复杂度为 O(n²)
  • 平均情况 :分区较为均衡,时间复杂度为 O(n log n)

优化策略

  1. 随机化基准值:随机选择基准值,避免最坏情况。
  2. 切换到插入排序:当子数组长度小于一定阈值时,使用插入排序提高效率。

五、快速排序与归并排序的对比

特性 快速排序 归并排序
时间复杂度 平均 O(n log n),最坏 O(n²) 始终 O(n log n)
空间复杂度 原地排序,O(log n) O(n)
稳定性 不稳定 稳定
适用场景 数据量大且内存有限 数据量大且对稳定性有要求

六、总结与展望

通过这篇文章,我们学习了快速排序的核心思想、分区方法以及完整实现。快速排序是基于分治法的高效算法,但它的性能依赖于分区点的选择,因此需要适当优化。

下一篇文章将聚焦于归并排序和堆排序,继续探索高级排序算法的魅力,敬请期待!

快速排序是排序算法中的明星选手,以其高效性和实用性广受欢迎。掌握快速排序,不仅能提升你对分治法的理解,还能为实际开发中优化程序性能打下基础。

如果你有疑问或需要进一步讲解的地方,欢迎在评论区讨论,我们一起进步!

相关推荐
qystca4 分钟前
洛谷 P1595 信封问题 C语言dp
算法
deja vu水中芭蕾14 分钟前
嵌入式C面试
c语言·开发语言
爱码小白14 分钟前
PyQt5 学习方法之悟道
开发语言·qt·学习方法
aaasssdddd9616 分钟前
C++的封装(十四):《设计模式》这本书
数据结构·c++·设计模式
芳菲菲其弥章22 分钟前
数据结构经典算法总复习(下卷)
数据结构·算法
yyyyyyykk23 分钟前
数据结构--链表
数据结构·链表
我是一只来自东方的鸭.34 分钟前
1. K11504 天平[Not so Mobile,UVa839]
数据结构·b树·算法
星语心愿.1 小时前
D4——贪心练习
c++·算法·贪心算法
光头man1 小时前
【八大排序(二)】希尔排序
算法·排序算法
武昌库里写JAVA1 小时前
使用React Strict DOM改善React生态系统
数据结构·vue.js·spring boot·算法·课程设计