快速排序算法及其优化

最新推荐文章于 2025-04-26 21:42:11 发布
最新推荐文章于 2025-04-26 21:42:11 发布
阅读量563 收藏 19
点赞数 18
文章标签： 排序算法 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cmder1000/article/details/147182496
版权

快速排序（QuickSort）是一种高效的分治排序算法，其核心思想是选取一个基准值（pivot），将数组分成两部分：一部分所有元素小于等于基准值，另一部分所有元素大于基准值。然后对这两部分递归应用相同的操作，直到子数组规模为 0 或 1。

快速排序的步骤分三步：

  1. 选择基准值：通常选数组的第一个、最后一个、中间或随机元素作为 pivot。例如，选择最后一个元素。
  2. 分区（Partition）：将数组重新排列，使得左边部分的所有元素 <= pivot，右边部分的所有元素 > pivot。最终 pivot 位于其正确排序位置。实现方式是用两个指针 i 和 j ，i 指向小于 pivot 的部分的边界，j 遍历数组，交换元素以满足条件。
  3. 递归排序：对 pivot 左侧和右侧的子数组递归调用快速排序。

Java 代码实现：

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

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

递归的终止条件：如果 low >= high，说明子数组为空或只有一个元素，无需排序，直接返回。

快速排序的时间复杂度取决于分区平衡性和递归深度，主要分以下几种情况：

  1. 平均情况：O(nlogn)

    假设每次 partition 将数组大致分成两等份，pivot 接近中位数，每次 partition 遍历子数组，比较和交换操作需要 O(n) 时间（n 是子数组大小）。假设数组每次均分为两半，递归树的深度为 O(logn)，因为每次子数组规模减半。每一层的总工作量是O(n)（所有子数组的元素总数约为 n ）。总时间复杂度 = 每层工作量 O(n) × 层数 O(logn) = O(nlogn)。这种情况出现在随机数据或 pivot 选择较好时。

  2. 最坏情况：O(n²)

    假设每次 partition 分区极不平衡，比如数组已排序（升序或降序），且 pivot 选最后一个元素，或者数组元素全部相同。每次 partition 将数组分为两部分：一部分为空或只有一个元素，另一部分包含剩余 n-1 个元素。递归树的深度为O(n)，因为每次只减少一个元素。每次 partition 仍需 O(n) 时间（遍历整个子数组）。总时间复杂度 = 每层工作量 O(n) + O(n-1) + … + O(1) = O(n²)。这种情况出现在已排序数组、逆序数组或全相同元素且pivot 固定选最后一个元素时。

  3. 最好情况：O(nlogn)

    每次 partition 完美地将数组分成两等份（pivot 恰好是中位数）。与平均情况类似，递归深度为 O(log n)，每层工作量为 O(n)，总时间为 O(n log n)。这种情况极少发生，除非 pivot 选择机制（如三数取中）确保接近中位数。

快速排序的空间复杂度主要由递归调用栈和辅助变量决定。在递归调用栈中，平均情况下，当分区平衡时，递归树的深度为 O(logn)，每次递归调用在栈上存储常量级的变量（low、high、pi 等），因此栈空间为O(log n)。最坏情况下，当分区极不平衡时（例如已排序数组），递归深度为 O(n)。每次递归调用仍存储常数级变量，栈空间为 O(n)。partition 方法中使用局部变量：pivot、i、j、temp，均为 O(1)。排序是原地进行的（通过交换元素，不需要额外数组），因此没有额外的 O(n) 空间。所以快速排序的总空间复杂度由递归栈主导，平均情况是O(log n)，最坏情况是O(n)。

快速排序的四种优化算法：

  1. 随机化 Pivot，通过随机选择 pivot，避免最坏情况（如已排序数组或全相同元素），使分区更平衡，平均时间复杂度更稳定为 O(n log n)。
import java.util.Random;

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

static int partition(int[] arr, int low, int high) {
    // 随机化 pivot
    Random rand = new Random();
    int randomIndex = low + rand.nextInt(high - low + 1);
    // 交换随机索引与 high
    int temp = arr[randomIndex];
    arr[randomIndex] = arr[high];
    arr[high] = temp;

    int pivot = arr[high];
    int i = low - 1;
    for (int j = low; j < high; j++) {
        if (arr[j] <= pivot) {
            i++;
            temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
    temp = arr[i + 1];
    arr[i + 1] = arr[high];
    arr[high] = temp;
    return i + 1;
}
  1. 三数取中，通过选择首、尾、中间元素的中位数作为 pivot，尽量使分区平衡，减少最坏情况发生。
static 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);
    }
}

static int partition(int[] arr, int low, int high) {
    // 三数取中
    int mid = low + (high - low) / 2;
    // 比较 low, mid, high 三个位置的值，找出中位数
    int pivotIndex;
    if ((arr[low] <= arr[mid] && arr[mid] <= arr[high]) || (arr[high] <= arr[mid] && arr[mid] <= arr[low])) {
        pivotIndex = mid;
    } else if ((arr[mid] <= arr[low] && arr[low] <= arr[high]) || (arr[high] <= arr[low] && arr[low] <= arr[mid])) {
        pivotIndex = low;
    } else {
        pivotIndex = high;
    }
    // 将中位数交换到 high
    int temp = arr[pivotIndex];
    arr[pivotIndex] = arr[high];
    arr[high] = temp;

    int pivot = arr[high];
    int i = low - 1;
    for (int j = low; j < high; j++) {
        if (arr[j] <= pivot) {
            i++;
            temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
    temp = arr[i + 1];
    arr[i + 1] = arr[high];
    arr[high] = temp;
    return i + 1;
}
  1. 小数组优化，对小规模子数组（例如长度 ≤ 10），使用插入排序替代快速排序，减少递归开销和函数调用，提高性能。
static void quickSort(int[] arr, int low, int high) {
    // 小数组优化，阈值设为 10
    if (high - low + 1 <= 10) {
        insertionSort(arr, low, high);
        return;
    }
    if (low < high) {
        int pi = partition(arr, low, high);
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

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

// 插入排序实现
static void insertionSort(int[] arr, int low, int high) {
    for (int i = low + 1; i <= high; i++) {
        int key = arr[i];
        int j = i - 1;
        while (j >= low && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}
  1. 重复元素优化，优化大量重复元素的情况，避免因 arr[j] <= pivot 导致的不必要交换，减少比较和移动次数。将数组分为三部分，小于 pivot 的元素、等于 pivot 的元素和大于 pivot 的元素。
static void quickSort(int[] arr, int low, int high) {
    if (low < high) {
        int[] result = partitionThreeWay(arr, low, high);
        int lt = result[0], gt = result[1];
        quickSort(arr, low, lt - 1);
        quickSort(arr, gt + 1, high);
    }
}

static int[] partitionThreeWay(int[] arr, int low, int high) {
    int pivot = arr[high];
    int lt = low;      // 小于 pivot 区域右边界
    int gt = high;     // 大于 pivot 区域左边界
    int i = low;       // 当前处理元素

    while (i <= gt) {
        if (arr[i] < pivot) {
            int temp = arr[lt];
            arr[lt] = arr[i];
            arr[i] = temp;
            lt++;
            i++;
        } else if (arr[i] > pivot) {
            int temp = arr[gt];
            arr[gt] = arr[i];
            arr[i] = temp;
            gt--;
        } else {
            i++; // 等于 pivot，直接跳过
        }
    }
    return new int[]{lt, gt}; // 返回小于和大于区域的边界
}

综合以上优化算法，可以得到一个更加鲁棒的快速排序实现：

import java.util.Random;

static void quickSort(int[] arr, int low, int high) {
    // 小数组优化
    if (high - low + 1 <= 10) {
        insertionSort(arr, low, high);
        return;
    }
    if (low < high) {
        int[] result = partitionThreeWay(arr, low, high);
        int lt = result[0], gt = result[1];
        quickSort(arr, low, lt - 1);
        quickSort(arr, gt + 1, high);
    }
}

static int[] partitionThreeWay(int[] arr, int low, int high) {
    // 三数取中
    int mid = low + (high - low) / 2;
    int pivotIndex;
    if ((arr[low] <= arr[mid] && arr[mid] <= arr[high]) || (arr[high] <= arr[mid] && arr[mid] <= arr[low])) {
        pivotIndex = mid;
    } else if ((arr[mid] <= arr[low] && arr[low] <= arr[high]) || (arr[high] <= arr[low] && arr[low] <= arr[mid])) {
        pivotIndex = low;
    } else {
        pivotIndex = high;
    }
    // 随机化 pivot（可选，进一步增强鲁棒性）
    Random rand = new Random();
    if (rand.nextBoolean()) {
        pivotIndex = low + rand.nextInt(high - low + 1);
    }
    // 交换到 high
    int temp = arr[pivotIndex];
    arr[pivotIndex] = arr[high];
    arr[high] = temp;

    int pivot = arr[high];
    int lt = low, gt = high, i = low;
    while (i <= gt) {
        if (arr[i] < pivot) {
            temp = arr[lt];
            arr[lt] = arr[i];
            arr[i] = temp;
            lt++;
            i++;
        } else if (arr[i] > pivot) {
            temp = arr[gt];
            arr[gt] = arr[i];
            arr[i] = temp;
            gt--;
        } else {
            i++;
        }
    }
    return new int[]{lt, gt};
}

static void insertionSort(int[] arr, int low, int high) {
    for (int i = low + 1; i <= high; i++) {
        int key = arr[i];
        int j = i - 1;
        while (j >= low && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}
说码解字
关注
排序算法 | 快速排序算法及其优化
ZY-JIMMY
11-20 1783
目录 快速排序(Quick Sort) 1、算法描述 2、算法分析——快速排序一次划分的三种实现方式 （1） 挖坑法 （2） 左右指针法 （3） 前后指针法 3、算法分析——快速排序基准数的三种选取方式 （1）固定位置选取基准 （2）随机位置选取基准 （3）三分取中法选取基准 4、算法分析——快速排序的两种优化 （1）当数据量很小时，采用直接插入排序 （2）聚集相同基准法...
快速排序及优化方案
weixin_43899008的博客
02-20 6852
文章目录快速排序及其优化方案1. 快速排序的流程2. 快速排序的实现时间复杂度计算3. 快速排序优化随机获取基准值进行优化3.2二路快速排序原理：思想：4. 总结 快速排序及其优化方案 1. 快速排序的流程 首先设定一个分界值，通过该分界值将数组分成左右两部分。 将大于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边，而等于分分界值的部分放在相对中间的部分。此时，左边部分中各元素都小于分界值，而右边部分中各元素都大于分界值，相对中间的部分的的数据等于分界值。 然后，左边和右边的数据可以独立排序
【决战西二旗】|快速排序的优化
kkkkk0826的专栏
12-02 501
1.前言 前面的一篇文章https://www.cnblogs.com/backnullptr/p/11934841.html讲了快速排序的基本概念、核心思想、基础版本代码实现等，让我们对快速排序有了一个充分的认识，但还无法达到面试中对快速排序灵活应对的程度。 快速排序是图领奖得主发明的算法，被誉为20世纪最重要的十大算法之一，快速排序为了可以在多种数据集都有出色的表现，进行了非常多的优化，因...
快排的优化
枯树无花
05-05 662
https://www.cnblogs.com/c4isr/p/4603980.html https://blog.csdn.net/qq_19525389/article/details/81436838
快速排序及优化方法
最新发布
lsy1118的博客
04-26 496
先设置好大框架，while(x<y),这里选择序列最左边的元素为基准值，所以先从序列的右边和这个基准值进行比较（我们将这个序列按从小到大的顺序输出）， 如果右边arr[y]比基准值小，我们就将y--，然后继续与基准值比较，直到找到小于它的元素，然后跳出循环，进入if判断语句，向这里if后面的语句分为两步理解，先赋值，后++，arr[x]=arr[y],x++;具体类似无监督插入排序，简单的理解就是优化判断条件，减少判断条件次数 ，优化分区代码执行过程中的判断条件，减少判断次数，进而减少算法的运行时间。
关于快排的优化
LuKeYY825的博客
08-18 217
快排优化博客链接：https://blog.csdn.net/qq_38289815/article/details/82718428
快速排序的优化
qq_49881112的博客
03-11 1739
1.递归的快速排序优化 第一种优化思想： 1.首先快速排序对于大量数据比如以万为计量单位，那么快排的时间复杂度和空间复杂度都是相对于其他几个排序都是最好的，那么对于少量数据比如10个，100个，快速排序显然已经不是最好的了； 2.那么快速排序每次经过找基准，这样数据就在慢慢趋于有序，这个时候当low和high之间的数据小于一个给定的值的时候，比如100，我们就可以之间调用之间插入排序来进行排序； public static void quick(int[] arr,int low,int high){
快速排序算法在Rust语言的实现及其优化
12-23
③ 实现快速排序算法并进行性能优化；④ 处理边界情况，确保算法的健壮性；⑤ 设计和运行测试用例，验证算法的正确性和性能。 阅读建议：建议读者按照文章的结构逐步阅读，从环境配置到算法实现再到性能优化，最后...
Python快速排序算法详解及优化策略
12-23
内容概要：本文详细介绍了Python中的快速排序算法，从基本原理到优化策略，再到性能对比和实际应用，帮助读者全面了解这一高效排序算法。文章首先解释了快速排序的基本原理，即通过分治法选择基准元素并进行分区操作...
Python快速排序算法的基础原理、优化与应用指南
01-06
适合人群：熟悉Python语言并希望深入了解快速排序算法及其性能优化的中级开发者。 使用场景及目标：①了解快速排序的工作机制及其理论背景；②掌握各种优化策略以应对不同类型的数据集；③将快速排序应用于大规模...
PHP排序算法之快速排序(Quick Sort)及其优化算法详解
01-20
本文实例讲述了PHP排序算法之快速排序(Quick Sort)及其优化算法。分享给大家供大家参考，具体如下： 基本思想： 快速排序（Quicksort）是对冒泡排序的一种改进。他的基本思想是：通过一趟排序将待排记录分割成独立的...
快速排序的4种优化
热门推荐
Tyler_Zx的博客
09-15 5万+
快排思想 快排基准的选择 固定基准 随机基准 三数取中 快速排序的优化 优化1：序列长度达到一定大小时，使用插入排序 优化2：尾递归优化 优化3：聚集元素 优化4：多线程处理快排 快排思想 快排算法是基于分治策略的排序算法，其基本思想是，对于输入的数组a[low, high]，按以下三个步骤进行排序。 (1)分解：以a[...
快速排序及其优化
weixin_39034379的博客
09-13 3170
3.快速排序及其优化 **并没有最好的排序算法，只有最适合的排序算法。**在面对不同规模的数据和不同排列的数据的时候，都有着适合当前数据的排序算法，一个好的排序算法就是面对合适的场景去选取最适合它的排序算法。 3.1 普通快速排序 **快排的思想找到一个值使得数组左边的值都是小于等于它的数，数组的右边都是大于它的数。**然后继续去操作左右区间。可以看到，分成左右区间后，分别对不同的区间继续当前操作，非常适合递归。 如上图所示，需要两个指针。 j 数组遍历的位置，i 第一个大于等于 选取的基准值的位置。 遍
快排的三种优化方式。
foreveyking的博客
08-09 2606
对于快排而言，其核心在partition中，主要是对于pivot的选取上，所以我们可以按以下三种方案进行优化： 1.在数组长度大于某一个阈值范围时，我们进行递归快排，当数据长度小于阈值时，我们进行插入排序。 2.在partition中选取pivot时，选取首尾中的进行比较，选取中位数为pivot，以保证pivot能够尽可能的固定在中间，而让两端递归的子数组更加均衡。 3.进行三路partit...
快速排序的优化思路
m0_53157173的博客
04-10 977
在对快速排序进行优化前，先让我们回顾一些快速排序的思想： 快速排序就是分而治之思想的体现，将有序序列分成对立的两部分，一部分值都比关键字值小，一部分值都比关键字值大，再分别对两部分进行排序 对快速排序不了解的可以先看看快速排序的具体过程和代码讲解 下面来看代码： #include<iostream> #include<algorithm> using namespace std; //该函数作用：把比关键字小的放到关键字的左边，比关键字大的放到关键字右边 int partition(
快速排序详解及优化方式
HYY的博客
04-27 2405
快速排序的时间复杂度是O(n log n)，其中n为待排序数组的长度。快速排序的每次划分操作需要O(n)的时间复杂度，而递归调用的次数为O(log n)，因此总的时间复杂度为O(n log n)。在最坏的情况下，即数组已经有序的情况下，快速排序的时间复杂度为O(n^2)。
快速排序的四种优化方式
董皓宇
03-16 2063
快速排序的四种优化方式 本文只讲述概念。 选用基准值（不在四种优化方式中） 选用基准值有三种方式，选用的基准值较好，快速排序的性能也会较好。 固定基准（也就是从begin的位置，作为排序的基准，没有一点优化，简单的快排方式都是这样） 随机基准（和固定基准差不多） 三数取中，这个基准就稍微优化了一些，从一堆数据中随机找出三个数据，把中间数据作为基准值，可以说是进行了稍微的优化。 下面讲一下四种优...
快排优化
weixin_30655219的博客
09-12 322
由于受到基准数pivot的影响，快排不是稳定的排序算法（最快为nlogn，最差为n^2）。 有三种比较有效的优化方法： 1、使用插入排序：在子序列比较小的时候，插入排序是比较快的。可以设置一个阈值n，当大于n个元素，子序列继续递归，否则选用插入排序。 2、pivot选用中位数。 3、三路划分：如果待排序列中重复元素过多，会大大影响排序的性能。 　　多使用2个游标在某一趟递归的两端，在原来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值