STL中sort的底层实现

news2024/11/19 16:21:06

文章目录

  • 1、源码分析
  • 2、算法优化
  • 3、总结

在讲解STL中sort的底层原理之前，先引申出这样几个问题？

①STL中sort的底层是采用哪种或者哪几种排序？
②STL中sort会导致栈溢出吗？
③快速排序的时间复杂度是不稳定的 l o g 2 n log_2n log2​n，最坏情况会变为n2，如何解决？
④STL中sort是如何控制递归深度的，如果已经到达了递归的深度，此时还没排完序该怎么办？

1、源码分析

C++STL中的sort默认会给我们提供两个接口，如下：

template <class RandomAccessIterator> void sort (RandomAccessIterator first, RandomAccessIterator last)
template <class RandomAccessIterator, class Compare> void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp)

第一个函数，有两个参数，分别表示迭代器的起始位置，和结束位置，它俩之间就是需要排序的区间

第二个函数，多了一个参数Compare comp，它比较的方式，可以是一个普通函数，或者是仿函数，或者是lambda表达式

如果我们不指定比较方式，默认采用升序排序

以下是vs2017的sort的源码，位置在\include\algorithm中

const int _ISORT_MAX = 32;	// maximum size for insertion sort

template<class _RanIt,
	class _Pr> inline
	void _Sort_unchecked(_RanIt _First, _RanIt _Last, _Iter_diff_t<_RanIt> _Ideal, _Pr _Pred)
	{	// order [_First, _Last), using _Pred
	_Iter_diff_t<_RanIt> _Count;
	while (_ISORT_MAX < (_Count = _Last - _First) && 0 < _Ideal)
		{	// divide and conquer by quicksort
		auto _Mid = _Partition_by_median_guess_unchecked(_First, _Last, _Pred);
		// TRANSITION, VSO#433486
		_Ideal = (_Ideal >> 1) + (_Ideal >> 2);	// allow 1.5 log2(N) divisions

		if (_Mid.first - _First < _Last - _Mid.second)
			{	// loop on second half
			_Sort_unchecked(_First, _Mid.first, _Ideal, _Pred);
			_First = _Mid.second;
			}
		else
			{	// loop on first half
			_Sort_unchecked(_Mid.second, _Last, _Ideal, _Pred);
			_Last = _Mid.first;
			}
		}

	if (_ISORT_MAX < _Count)
		{	// heap sort if too many divisions
		_Make_heap_unchecked(_First, _Last, _Pred);
		_Sort_heap_unchecked(_First, _Last, _Pred);
		}
	else if (2 <= _Count)
		{
		_Insertion_sort_unchecked(_First, _Last, _Pred);	// small
		}
	}

template<class _RanIt,
	class _Pr> inline
	void sort(const _RanIt _First, const _RanIt _Last, _Pr _Pred)
	{	// order [_First, _Last), using _Pred
	_Adl_verify_range(_First, _Last);  //用于检查区间的合法性
	const auto _UFirst = _Get_unwrapped(_First);
	const auto _ULast = _Get_unwrapped(_Last);
	_Sort_unchecked(_UFirst, _ULast, _ULast - _UFirst, _Pass_fn(_Pred));
	}

template<class _RanIt> inline
	void sort(const _RanIt _First, const _RanIt _Last)
	{	// order [_First, _Last), using operator<
	_STD sort(_First, _Last, less<>());
	}

我们在调用sort时(没有传入第三个参数)，在algorithm中会去调用sort(const _RanIt _First, const _RanIt _Last)，在内部会调用sort(const _RanIt _First, const _RanIt _Last, _Pr _Pred)，进而会去调用_Sort_unchecked(_RanIt _First, _RanIt _Last, _Iter_diff_t<_RanIt> _Ideal, _Pr _Pred)

因此，主要调用的就是_Sort_unchecked函数：

void _Sort_unchecked(_RanIt _First, _RanIt _Last, _Iter_diff_t<_RanIt> _Ideal, _Pr _Pred)

_First：首元素的迭代器
_Last：末尾元素下一个位置的迭代器
_Ideal：递归层数
_Pred：指定的排序方式

在_Sort_unchecked函数中，如果需要排序的元素是否大于_ISORT_MAX(32)并且递归深度大于0，就进入while循环，通过_Partition_by_median_guess_unchecked函数选取一个mid，然后更新当前排序元素个数的递归深度，接着会递归调用_Sort_unchecked函数。

如果没有进入while循环，就说明但当前排序的元素个数小于等于_ISORT_MAX(32)，或者递归深度小于等于0，接着就判断当前排序的元素个数是否大于_ISORT_MAX(32)，如果是则说明递归深度小于等于0，因此就采用堆排序来控制递归深度

如果上述条件都没满足，则说明需要排序的元素小于等于32，大于2，此时采用插入排序来进行优化

递归的深度通过以下方式来控制，每次递归，递归的深度都会通过以下方式减少

_Ideal = (_Ideal >> 1) + (_Ideal >> 2);	// allow 1.5 log2(N) divisions

最多允许递归1.5*log2(N)层，比如需要排序的元素为1024，那么1.5*log2(1024)=15层，因此最多递归15层，如果需要排序的元素为512，那么最多递归8层

2、算法优化

在这里就不再过多赘述快排的原理，如果还有不知道的小伙伴，就看看我以往写的博客快速排序

因为快排需要选一个基准值用于比较，如果只是单纯的选择最左边的值或者选择最右边的，当将一个有序数列进行反向排序时(升序改为降序，降序改为升序)，那么时间复杂度必然为n2，为了防止这个问题，在_Guess_median_unchecked函数内还进行了优化，优化的方式就是三数取中

auto _Mid = _Partition_by_median_guess_unchecked(_First, _Last, _Pred);

template<class _RanIt,
	class _Pr> inline
	pair<_RanIt, _RanIt>
		_Partition_by_median_guess_unchecked(_RanIt _First, _RanIt _Last, _Pr _Pred)
	{	// partition [_First, _Last), using _Pred
	//这里取了一个中间值，但是在_Guess_median_unchecked内部会对该位置的数据进行优化
	_RanIt _Mid = _First + ((_Last - _First) >> 1);	// TRANSITION, VSO#433486
	_Guess_median_unchecked(_First, _Mid, _Last - 1, _Pred);
	_RanIt _Pfirst = _Mid;
	_RanIt _Plast = _Pfirst + 1;

	while (_First < _Pfirst
		&& !_DEBUG_LT_PRED(_Pred, *(_Pfirst - 1), *_Pfirst)
		&& !_Pred(*_Pfirst, *(_Pfirst - 1)))
		{
		--_Pfirst;
		}

	while (_Plast < _Last
		&& !_DEBUG_LT_PRED(_Pred, *_Plast, *_Pfirst)
		&& !_Pred(*_Pfirst, *_Plast))
		{
		++_Plast;
		}

	_RanIt _Gfirst = _Plast;
	_RanIt _Glast = _Pfirst;

	for (;;)
		{	// partition
		for (; _Gfirst < _Last; ++_Gfirst)
			{
			if (_DEBUG_LT_PRED(_Pred, *_Pfirst, *_Gfirst))
				{
				}
			else if (_Pred(*_Gfirst, *_Pfirst))
				{
				break;
				}
			else if (_Plast != _Gfirst)
				{
				_STD iter_swap(_Plast, _Gfirst);
				++_Plast;
				}
			else
				{
				++_Plast;
				}
			}

		for (; _First < _Glast; --_Glast)
			{
			if (_DEBUG_LT_PRED(_Pred, *(_Glast - 1), *_Pfirst))
				{
				}
			else if (_Pred(*_Pfirst, *(_Glast - 1)))
				{
				break;
				}
			else if (--_Pfirst != _Glast - 1)
				{
				_STD iter_swap(_Pfirst, _Glast - 1);
				}
			}

		if (_Glast == _First && _Gfirst == _Last)
			{
			return (pair<_RanIt, _RanIt>(_Pfirst, _Plast));
			}

		if (_Glast == _First)
			{	// no room at bottom, rotate pivot upward
			if (_Plast != _Gfirst)
				{
				_STD iter_swap(_Pfirst, _Plast);
				}

			++_Plast;
			_STD iter_swap(_Pfirst, _Gfirst);
			++_Pfirst;
			++_Gfirst;
			}
		else if (_Gfirst == _Last)
			{	// no room at top, rotate pivot downward
			if (--_Glast != --_Pfirst)
				{
				_STD iter_swap(_Glast, _Pfirst);
				}

			_STD iter_swap(_Pfirst, --_Plast);
			}
		else
			{
			_STD iter_swap(_Gfirst, --_Glast);
			++_Gfirst;
			}
		}
	}

这个Mid会返回两个值，[Mid.first，Mid.second]范围内是等于基准值的

选择基准值时，还调用函数_Guess_median_unchecked进行了优化，这个函数就是三数取中

template<class _RanIt,
	class _Pr> inline
	void _Guess_median_unchecked(_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred)
	{	// sort median element to middle
	using _Diff = _Iter_diff_t<_RanIt>;
	const _Diff _Count = _Last - _First;
	if (40 < _Count)
		{	// median of nine
		const _Diff _Step = (_Count + 1) >> 3; // +1 can't overflow because range was made inclusive in caller
		const _Diff _Two_step = _Step << 1; // note: intentionally discards low-order bit
		_Med3_unchecked(_First, _First + _Step, _First + _Two_step, _Pred);
		_Med3_unchecked(_Mid - _Step, _Mid, _Mid + _Step, _Pred);
		_Med3_unchecked(_Last - _Two_step, _Last - _Step, _Last, _Pred);
		_Med3_unchecked(_First + _Step, _Mid, _Last - _Step, _Pred);
		}
	else
		{
		_Med3_unchecked(_First, _Mid, _Last, _Pred);
		}
	}

这里首先会判断需要排序的元素个数_Count = _Last - _First如果大于40个，则会在if内部定义两个变量，_Step 和 _Two_step，分别表示从区间的起始位置开始的1/8位置处和1/4位置处，此时就有9个位置，_First，_First + _Step，_First + _Two_step，_Mid - _Step，_Mid，_Mid + _Step，_Last - _Two_step，_Last - _Step，_Last。如图所示：

在这里插入图片描述

接着通过4组_Med3_unchecked函数，将该9个位置的数据，按照特定的排序规则排序(升序或者降序)

如果需要排序的元素个数大于40，则只需_Last，_Mid 和 _Last 位置所在的数据按照特定的排序规则排序(升序或者降序)

_Med3_unchecked函数

template<class _RanIt,
	class _Pr> inline
	void _Med3_unchecked(_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred)
	{	// sort median of three elements to middle
	if (_DEBUG_LT_PRED(_Pred, *_Mid, *_First))
		{
		_STD iter_swap(_Mid, _First);
		}

	if (_DEBUG_LT_PRED(_Pred, *_Last, *_Mid))
		{	// swap middle and last, then test first again
		_STD iter_swap(_Last, _Mid);

		if (_DEBUG_LT_PRED(_Pred, *_Mid, *_First))
			{
			_STD iter_swap(_Mid, _First);
			}
		}
	}

_DEBUG_LT_PRED这个宏的作用就是判断后两个参数，也就是位置所对应的数据是否按照特定的排序方式(_Pred)排序，如果不是的话，就通过iter_swap交换

通过_Guess_median_unchecked(_First, _Mid, _Last - 1, _Pred)这个函数，我们已经取得mid基准值，并且mid位置的数据一定大于等于_First，并且小于等于_Last - 1

接着会定义 _Pfirst 和 _Plast

_RanIt _Pfirst = _Mid;
_RanIt _Plast = _Pfirst + 1;

此时的位置关系图如下：

在这里插入图片描述

后面两个while是用来选等于基准值的数，最后_Pfirst的处等于基准值，而_Pfirst + 1一定不等于基准值

接着会定义_Gfirst 和 _Glast

_RanIt _Gfirst = _Plast;
_RanIt _Glast = _Pfirst;

位置关系如下：

在这里插入图片描述

下面的两个for循环就是分别是_Gfirst出发向右走，_Glast出发向左走，以_Gfirst为例子，如果遇到大于基准值(_Pfirst)那么进行下一轮循环，如果小于，那么break，然后在下面和_Glast交换，如果是相等那么和_Plast交换并更新

3、总结

①STL中sort的底层是采用哪种或者哪几种排序？

采用三种排序
如果元素的个数小于等于32，那么就直接使用插入排序

如果元素的个数大于32，但是已经达到最大的递归深度，则采用堆排序
这里为什么采用堆排序，而不采用归并排序呢？因为堆排序不需要消耗额外的空间

如果元素的个数大于32，但还没达到最大的递归深度，则采用快速排序

STL中sort会导致栈溢出吗？

不会，因为对最大的递归深度做了限制，最大的深度不能超过1.5*log2(N)层

③快速排序的时间复杂度是不稳定的 l o g 2 n log_2n log2​n，最坏情况会变为n2，如何解决？

sort快排进行了优化，即对基准值做了优化，如果基准值恰好是最大或者最小值那么快排的复杂度会达到n2，因此需要选择一个适中的基准值。如果元素个数大于40个，那么会将整个区间划分为8段，9个位置，对这个9个位置的数据进行排序，最终取出mid。如果元素个数小于等于40个，那么会将整个区间划分为2段，3个位置，对这个3个位置的数据进行排序，最终取出mid。

④STL中sort是如何控制递归深度的，如果已经到达了递归的深度，此时还没排完序该怎么办？

通过这行代码控制递归深度

_Ideal = (_Ideal >> 1) + (_Ideal >> 2);	// allow 1.5 log2(N) divisions

最大的深度不能超过1.5*log2(N)层，如果超过了最大递归深度，则采用堆排序

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1313484.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

cec2013(python):鸡群优化算法（Chicken Swarm Optimization, CSO）

cec2013(python):鸡群优化算法（Chicken Swarm Optimization, CSO）

一、鸡群优化算法CSO求解cec2013 1.cec2013函数简介 CEC 2013 Special Session on Real-Parameter Optimization中共有28个测试函数维度可选择为10/30/50/100。 每个测试函数的详细信息如下表所示&#xff1a; cec2013参考文献&#xff1a; [1] Liang J J , Qu B Y , Sugan…
阅读更多...
IT 人员与加密程序：如何战胜病毒

IT 人员与加密程序：如何战胜病毒

&#x1f510; 加密程序是攻击者在成功攻击组织时使用最多的恶意软件类型。它们通常会发送到一个庞大的电子邮件地址数据库&#xff0c;看起来像 Word 或 Excel 文档或 PDF 文件。 想象一下&#xff0c;你是会计部门的一名员工。这种格式的文件在电子文档管理系统中被广泛使用…
阅读更多...
前端js实现将异步封装成promise然后用async await转同步

前端js实现将异步封装成promise然后用async await转同步

&#xff08;一&#xff09;需求背景&#xff1a; 哈喽 大家好啊&#xff0c;今天遇到一个问题&#xff0c;需要将异步请求转换成同步 &#xff08;二&#xff09;相关代码&#xff1a; function getInfo() {return new Promise((resolve,reject)> {setTimeout(()> {re…
阅读更多...
3D点云广义零样本分类的递归循环对比生成网络笔记

3D点云广义零样本分类的递归循环对比生成网络笔记

1 Title Contrastive Generative Network with Recursive-Loop for 3D point cloud generalized zero-shot classification(Yun Hao, Yukun Su, Guosheng Lin, Hanjing Su, Qingyao Wu)【Pattern Recognition】 2 Conclusion This work aims to facilitate research on 3D poi…
阅读更多...
报错“找不到mfc100u.dll,程序无法继续执行”的解决方法，完美解决

报错“找不到mfc100u.dll,程序无法继续执行”的解决方法，完美解决

在软件操作过程中&#xff0c;部分用户可能遇到"计算机缺失mfc140u.dll导致无法启动程序"的困扰。这种情况常常发生在启动某特定应用&#xff0c;特别是需要VC Redistributable支持的软件时。以下为详尽解决策略&#xff0c;让用户轻松应对这类技术难题&#xff0c;重…
阅读更多...
【AI】如何准备mac开发vue项目的环境

【AI】如何准备mac开发vue项目的环境

为了在Mac上开发Vue项目&#xff0c;你需要准备一些工具和环境。以下是主要的步骤&#xff1a; 安装Node.js和npm&#xff1a; Vue.js是一个基于JavaScript的框架&#xff0c;因此你需要Node.js环境。访问Node.js官网下载并安装Node.js&#xff0c;这也会自动安装npm&#xff0…
阅读更多...
若依框架springboot——修改前端图片上传样式

若依框架springboot——修改前端图片上传样式

简述 使用过若依框架的&#xff0c;一定知道若依前端框架上传图片的样式&#xff0c;是一个正方形加号图片&#xff0c;但是如果你要使用自定义样式呢。 比如将下面这个图进行修改呢 修改后的样式 你可以直接找到element-ui 修改上传图片的组件&#xff0c;也可以加入新的组…
阅读更多...
JS的箭头函数this:

JS的箭头函数this:

箭头函数不会创建自己的this&#xff0c;它只会从自己的作用域链的上一层沿用this。 具体看实例&#xff1a; //以前&#xff1a;谁调用的这个函数 this就指向谁// console.log(this);//window// function fn(){// console.log(this);//window 因为这个函数也是window调用…
阅读更多...
机器学习入门笔记

机器学习入门笔记

文章目录 背景具体步骤1.环境搭建2.写个demo1.数据处理2.分割数据集3.用模型训练数据&#xff0c;并得到预测结果4.绘制结果5.评估 背景 最近学习了一些关于机器学习的内容&#xff0c;做个笔记。 具体步骤 1.环境搭建 需要用到的工具&#xff1a;pycharm&#xff0c;anaco…
阅读更多...
Python求小于m的最大10个素数

Python求小于m的最大10个素数

为了找到小于m的最大10个素数&#xff0c;我们首先需要确定m的值。然后&#xff0c;我们可以使用一个简单的算法来检查每一个小于m的数字是否是素数。 下面是一个Python代码示例&#xff0c;可以找到小于m的最大10个素数&#xff1a; def is_prime(n): if n < 1: …
阅读更多...
数据分析为何要学统计学（11）——如何进行时间序列分析

数据分析为何要学统计学（11）——如何进行时间序列分析

时间序列是由随时间变化的值构成&#xff0c;如产品销量、气温数据等等&#xff0c;该数据集合是个有序序列&#xff0c;除了数值&#xff0c;没有其他因素。通过对时间序列展开分析&#xff0c;能够回答如下问题&#xff1a; &#xff08;1&#xff09;被研究对象的活动特征是…
阅读更多...
VRRP协议详解

VRRP协议详解

目录 一、基础概念 1、概念 2、VRRP的基本结构 状态机 二、VRRP主备备份工作过程 1、备份工作过程 2、VRRP的负载分担工作 三、实验 一、基础概念 1、概念 VRRP能够在不改变组网的情况下&#xff0c;将多台路由器虚拟成一个虚拟路由器&#xff0c;通过配置虚拟路由器的I…
阅读更多...
常用函数之js复制图片至剪切板

常用函数之js复制图片至剪切板

背景 最近在工作中遇到了一个需求&#xff0c;点击按钮将Echart图复制到剪切板&#xff0c;然后按Ctrl&#xff08;command&#xff09;V可以直接复制到聊天软件&文档编辑器中。本以为这是一个比较简单的需求&#xff0c;好像找了一圈资料&#xff0c;发现事情并不简单&am…
阅读更多...
Vue 组件传参 emit

Vue 组件传参 emit

emit 属性&#xff1a;用于创建自定义事件&#xff0c;接收子组件传递过来的数据。 注意&#xff1a;如果自定义事件的名称&#xff0c;和原生事件的名称一样&#xff0c;那么只会触发自定义事件。 setup 语法糖写法请见&#xff1a;《Vue3 子传父 组件传参 defineEmits》 语…
阅读更多...
『番外篇二』Swift “黑魔法”之动态获取类实例隐藏属性的值

『番外篇二』Swift “黑魔法”之动态获取类实例隐藏属性的值

概览 在 Swift 代码的调试中，我们时常惊叹调试器的无所不能：对于大部分“黑盒”类实例的内容，调试器也都能探查的一清二楚。 想要自己在运行时也能轻松找到 Thread 实例“私有”属性的值吗（比如 seqNum）？ 在本篇博文中您将学到如下内容： 概览1. 借我，借我，一双慧眼吧…
阅读更多...
MFC画折线图，基于x64系统

MFC画折线图，基于x64系统

由于项目的需要&#xff0c;需要画一个折线图。 传统的Teechart、MSChart、HighSpeedChart一般是只能配置在x86系统下&#xff0c;等到使用x64系统下运行就是会报出不知名的错误&#xff0c;这个地方让人很苦恼。 我在进行配置的过程之中&#xff0c;使用Teechart将x86配置好…
阅读更多...
让测试效率起飞的8款浏览器兼容性测试工具，你get了吗？

让测试效率起飞的8款浏览器兼容性测试工具，你get了吗？

浏览器的兼容性问题&#xff0c;是指不同浏览器使用内核及所支持的 HTML 等网页语言标准不同&#xff0c;用户客户端的环境不同造成的显示效果不能达到理想效果。 对于用户而言&#xff0c;无论使用哪款浏览器&#xff0c;期望看到的效果是正常的统一的。市面上发布的浏览器版…
阅读更多...
CentOS 防火墙管理及使用的redis基本常用命令

CentOS 防火墙管理及使用的redis基本常用命令

文章目录 防火墙管理使用systemctl管理防火墙启动、关闭使用firewalld-cmd配置访问防火墙策略firewalld配置文件修改限制来源IP docker使用 redis 防火墙管理 需要关闭防火墙或者开启对应端口 使用systemctl管理防火墙启动、关闭 启动防火墙&#xff1a; systemctl start fi…
阅读更多...
微服务实战系列之ZooKeeper（上）

微服务实战系列之ZooKeeper（上）

前言 历经1个多月的创作和总结&#xff0c;纵观博主微服务系列博文&#xff0c;大致脉络覆盖了以下几个方面&#xff1a; 数据方面&#xff08;缓存&安全&#xff09; 比如Redis、MemCache、Ehcache、J2cache&#xff08;两级缓存框架&#xff09;、RSA加密、Sign签名…传…
阅读更多...
【LSM tree 】Log-structured merge-tree 一种分层、有序、面向磁盘的数据结构

【LSM tree 】Log-structured merge-tree 一种分层、有序、面向磁盘的数据结构

文章目录 前言基本原理读写流程写流程读流程 写放大、读放大和空间放大优化 前言 LSM Tree 全称是Log-structured merge-tree, 是一种分层&#xff0c;有序&#xff0c;面向磁盘的数据结构。其核心原理是磁盘批量顺序写比随机写性能高很多&#xff0c;可以通过围绕这一原理进行…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023