当前位置：首页 > news >正文

从三路快排到内省排序：探索工业级排序算法的演进

news 2025/11/9 7:51:13

前言

大家好啊，我是云泽Q，欢迎阅读我的文章，一名热爱计算机技术的在校大学生，喜欢在课余时间做一些计算机技术的总结性文章，希望我的文章能为你解答困惑~

一、快速排序性能的关键点分析

决定快排性能的关键点是每次单趟排序后，key对数组的分割，如果每次选key基本二分居中，那么快排的递归树就是棵均匀的满二叉树，性能最佳。但是实践中虽然不可能每次都是二分居中，但是性能也还是可控的。但是如果出现每次选到最小值/最大值，且数组中有大量重复的数据时，划分为0个和N-1的子问题时，时间复杂度为O（N²）

//数组中有多个跟key相等的值
int a[] = { 6,1,7,6,6,6,4,9 };
int a[] = { 3,2,3,3,3,3,2,3 };
//数组中全是相同的值
int a[] = { 2,2,2,2,2,2,2,2 };

下面就提供一种叫三路划分的解决方案

1.1 三路划分算法思想解析

当面对有大量跟key相同的值时，三路划分的核心思想有点类似hoare的左右指针和lomuto的前后指针的结合。核心思想是把数组中的数据分为三段[比key小的值]，[跟key相等的值]，[比key大的值]，所以叫做三路划分算法。结合下图，理解一下实现思想：

key默认取left位置的值，left指向区间最左边，right指向区间最右边，cur指向left+1位置
在这里插入图片描述
cur从左向右走，遇到比key小的值后跟left位置交换，换到左边，left++，cur++

可以看到此时left依旧指向key，cur遇到比key大的值跟right位置交换，换到右边，right减减

此时cur遇到的值（9）比key大，和right交换，换到右边，right减减
在这里插入图片描述
此时cur遇到的值比key小，跟left交换，换到左边，left++，cur减减

此时cur遇到和key相等的值，cur++，直到cur>right结束

//开始递归，中间和key相等的值不用动

1.2 三路快排单趟排序运行结果分析

排序数组，下面通过这个OJ题来展示一下三路划分快排在该场景下的表现，在这个OJ中，用快排的lomuto的方法时是过不了题目的（lomuto的前后指针面对大量数据重复时，效率会退化），hoare版本可以过这个题目，堆排序和归并和希尔是可以过的，其他几个O（N²）也过不了，因为这个题的测试用例中不仅仅有数据很多的大数组，也有一些特殊数据的数组。堆排序和归并和希尔不是很受数据样本的分布和形态的影响，但是快排会，因为快排要选key，每次key都当趟分隔都很偏，就会出现效率退化问题。
在这里插入图片描述

补充一下，三路划分虽然在针对有大量重复数据时效率很好，但也并不是完美的，如果三路划分单趟选基准值的时候，就是运气很差，每次划分选到的就是最小/次小的值作为key，那还是会有一些性能退化。没有一个排序算法是完美无瑕能同时兼备高效和稳定的，在一方面的效果很好情况下，必定是要在其他方面付出一些代价的，三路划分的排序思想在特殊场景下效率也会退化，所以算法的场景要结合具体的场景和需求。冒泡排序和直接插入排序除外除外，我个人觉得这两个排序算法除了有一些教学价值基本0作用

二、内省排序（优秀的工业级排序）

introsort是由David Musser在1997年设计的排序算法，C++sgi STL sort中就是用的introspective sort（内省排序）思想实现的。内省排序可以认为不受数据分布的影响，无论什么原因划分不均匀，导致递归深度太深，他就是转换堆排序了，堆排不受数据分布影响。

introsort是introspective sort采用了缩写，他的名字其实表达了他的实现思路，他的思路就是进行自我侦测和反省，快排递归深度太深(sgi STL中使用的是深度为2倍排序元素数量的对数值)那就说明在这种数据序列下，选key出现了问题，性能在快速退化，那么就不要再进行快排分割递归了，改换为堆排序进行排序。
在这里插入图片描述
这里计算深度是定义了一个参数值，每向下递归一层，这个形参就++

三、力扣源码

快排三路划分

void Swap(int* p, int* q)
{int tmp = *p;*p = *q;*q = tmp;
}void QuickSort(int* nums, int left, int right)
{if(left >= right){return;}int begin = left;int end = right;int randi = left + (rand() % (right - left + 1));Swap(&nums[left], &nums[randi]);int key = nums[left];int cur = left + 1;while(cur <= right){if(nums[cur] < key){Swap(&nums[cur], &nums[left]);++left;++cur;}else if(nums[cur] > key){Swap(&nums[cur], &nums[right]);--right;}else{++cur;}}QuickSort(nums, begin, left - 1);QuickSort(nums, right + 1, end);
}int* sortArray(int* nums, int numsSize, int* returnSize) {srand(time(0));QuickSort(nums, 0, numsSize-1);*returnSize = numsSize;return nums;
}

自省排序

void Swap(int* x, int* y) {int tmp = *x;*x = *y;*y = tmp;
}void AdjustDown(int* a, int n, int parent) {int child = parent * 2 + 1;while (child < n) {// 选出左右孩⼦中⼤的那⼀个if (child + 1 < n && a[child + 1] > a[child]) {++child;}if (a[child] > a[parent]) {Swap(&a[child], &a[parent]);parent = child;child = parent * 2 + 1;} else {break;}}
}void HeapSort(int* a, int n) {// 建堆 -- 向下调整建堆 -- O(N)for (int i = (n - 1 - 1) / 2; i >= 0; --i) {AdjustDown(a, n, i);}// O(N*logN)int end = n - 1;while (end > 0) {Swap(&a[end], &a[0]);AdjustDown(a, end, 0);--end;}
}void InsertSort(int* a, int n) {for (int i = 1; i < n; i++) {int end = i - 1;int tmp = a[i];// 将tmp插⼊到[0,end]区间中，保持有序while (end >= 0) {if (tmp < a[end]) {a[end + 1] = a[end];--end;} else {break;}}a[end + 1] = tmp;}
}void IntroSort(int* a, int left, int right, int depth, int defaultDepth) {if (left >= right)return;// 数组⻓度⼩于16的⼩数组，换为插⼊排序，简单递归次数if (right - left + 1 < 16) {InsertSort(a + left, right - left + 1);return;}// 当深度超过2*logN时改⽤堆排序if (depth > defaultDepth) {HeapSort(a + left, right - left + 1);return;}depth++;int begin = left;int end = right;// 随机选key int randi = left + (rand() % (right - left + 1));Swap(&a[left], &a[randi]);int prev = left;int cur = prev + 1;int keyi = left;while (cur <= right) {if (a[cur] < a[keyi] && ++prev != cur) {Swap(&a[prev], &a[cur]);}++cur;}Swap(&a[prev], &a[keyi]);keyi = prev;// [begin, keyi-1] keyi [keyi+1, end]IntroSort(a, begin, keyi - 1, depth, defaultDepth);IntroSort(a, keyi + 1, end, depth, defaultDepth);
}void QuickSort(int* a, int left, int right) {int depth = 0;int logn = 0;int N = right - left + 1;for (int i = 1; i < N; i *= 2) {logn++;}// introspective sort -- ⾃省排序IntroSort(a, left, right, depth, logn * 2);
}int* sortArray(int* nums, int numsSize, int* returnSize) {srand(time(0));QuickSort(nums, 0, numsSize - 1);*returnSize = numsSize;return nums;
}