来自<algorithm> c++自带排序sort的提取代码 | 内观排序模板

最新推荐文章于 2023-01-14 20:42:04 发布
最新推荐文章于 2023-01-14 20:42:04 发布
阅读量587 收藏
点赞数
分类专栏： C++ 文章标签： 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huanghongxun/article/details/50429906
版权

作死尝试提取STL..

#include <cstdio>
#include <cstdlib>

namespace std {
	
	struct input_iterator_tag {};
	struct output_iterator_tag {};
	struct forward_iterator_tag : public input_iterator_tag {};
	struct bidirectional_iterator_tag : public forward_iterator_tag {};
	struct random_access_iterator_tag : public bidirectional_iterator_tag {};
	
	enum { _S_threshold = 16 };
	
	struct __true_type {};
	struct __false_type {};
	
	template <class _Tp>
	struct __type_traits {
	    typedef __true_type     this_dummy_member_must_be_first;
	    typedef __false_type    has_trivial_default_constructor;
	    typedef __false_type    has_trivial_copy_constructor;
	    typedef __false_type    has_trivial_assignment_operator;
	    typedef __false_type    has_trivial_destructor;
	    typedef __false_type    is_POD_type;
	};
	
	template<typename _Iterator>
	struct iterator_traits {
	    typedef typename _Iterator::iterator_category iterator_category;
	    typedef typename _Iterator::value_type        value_type;
	    typedef typename _Iterator::difference_type   difference_type;
	    typedef typename _Iterator::pointer           pointer;
	    typedef typename _Iterator::reference         reference;
	};
	
	template<typename _Tp>
	struct iterator_traits<_Tp*>
	{
	    typedef random_access_iterator_tag iterator_category;
	    typedef _Tp                         value_type;
	    typedef ptrdiff_t                   difference_type;
	    typedef _Tp*                        pointer;
	    typedef _Tp&                        reference;
	};
	template <class _Iter>
	inline typename iterator_traits<_Iter>::iterator_category
	iterator_category(const _Iter& __i)
	{ return __iterator_category(__i); }
	
	template <class _Iter>
	inline typename iterator_traits<_Iter>::difference_type* distance_type(const _Iter&)
	{ return static_cast<typename iterator_traits<_Iter>::difference_type*>(0); }
	
	template<class _Iter>
	inline typename iterator_traits<_Iter>::value_type* value_type(const _Iter& __i)
	{ return static_cast<typename iterator_traits<_Iter>::value_type*>(0); }
	
	template<typename _Iter>
    inline typename iterator_traits<_Iter>::iterator_category __iterator_category(const _Iter&)
    { return typename iterator_traits<_Iter>::iterator_category(); }
    
	template<typename _Tp>
	inline const _Tp& __median(const _Tp& __a, const _Tp& __b, const _Tp& __c) {
	    if (__a < __b)
			if (__b < __c) return __b;
			else if (__a < __c) return __c;
			else return __a;
	    else if (__a < __c) return __a;
	    else if (__b < __c) return __c;
	    else return __b;
	}
	
	template<typename _Tp, typename _Compare>
	inline const _Tp& __median(const _Tp& __a, const _Tp& __b, const _Tp& __c, _Compare __comp) {
	    if (__comp(__a, __b))
			if (__comp(__b, __c)) return __b;
			else if (__comp(__a, __c)) return __c;
			else return __a;
	    else if (__comp(__a, __c)) return __a;
	    else if (__comp(__b, __c)) return __c;
	    else return __b;
	}
	
	template<typename _ForwardIterator1, typename _ForwardIterator2>
	inline void iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) {
	    typedef typename iterator_traits<_ForwardIterator1>::value_type _ValueType1;
	    typedef typename iterator_traits<_ForwardIterator2>::value_type _ValueType2;
	
	    const _ValueType1 __tmp = *__a;
	    *__a = *__b;
	    *__b = __tmp;
	}
	
	template<typename _RandomAccessIterator, typename _Tp>
	_RandomAccessIterator __unguarded_partition(_RandomAccessIterator __first,
				  _RandomAccessIterator __last, _Tp __pivot) {
	    while (1) {
		    while (*__first < __pivot) ++__first;
		    --__last;
		    while (__pivot < *__last) --__last;
		    if (!(__first < __last))
		        return __first;
		    iter_swap(__first, __last);
		    ++__first;
		}
	}
	template<typename _Size>
	inline _Size __lg(_Size __n) {
	    _Size __k;
	    for (__k = 0; __n != 1; __n >>= 1) ++__k;
	    return __k;
	}
	
	template<typename _RandomAccessIterator, typename _Tp>
	void __unguarded_linear_insert(_RandomAccessIterator __last, _Tp __val) {
	    _RandomAccessIterator __next = __last;
	    --__next;
	    while (__val < *__next) {
		    *__last = *__next;
		    __last = __next;
		    --__next;
		}
	    *__last = __val;
	}
	
	template<typename _Tp>
	struct _Is_normal_iterator {
	    typedef __false_type _Normal;
	};
	
	template<typename _BidirectionalIterator1, typename _BidirectionalIterator2>
	inline _BidirectionalIterator2 __copy_backward(_BidirectionalIterator1 __first,
			_BidirectionalIterator1 __last, _BidirectionalIterator2 __result,
			    bidirectional_iterator_tag) {
	    while (__first != __last) *--__result = *--__last;
	    return __result;
	}
	
	template<typename _BidirectionalIterator1, typename _BidirectionalIterator2, typename _BoolType>
	struct __copy_backward_dispatch {
	    static _BidirectionalIterator2
	    copy(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last, _BidirectionalIterator2 __result)
	    { return __copy_backward(__first, __last, __result, __iterator_category(__first)); }
	};

	template<typename _Tp>
    struct __copy_backward_dispatch<_Tp*, _Tp*, __true_type> {
    	static _Tp* copy(const _Tp* __first, const _Tp* __last, _Tp* __result) {
			const ptrdiff_t _Num = __last - __first;
			memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
			return __result - _Num;
		}
	};

	template<typename _Tp>
	struct __copy_backward_dispatch<const _Tp*, _Tp*, __true_type> {
		static _Tp* copy(const _Tp* __first, const _Tp* __last, _Tp* __result) {
			return  std::__copy_backward_dispatch<_Tp*, _Tp*, __true_type>::copy(__first, __last, __result);
		}
	};
	
	template<typename _BI1, typename _BI2>
	inline _BI2 __copy_backward_aux(_BI1 __first, _BI1 __last, _BI2 __result) {
		typedef typename __type_traits<typename iterator_traits<_BI2>::value_type>
					::has_trivial_assignment_operator _Trivial;
		return __copy_backward_dispatch<_BI1, _BI2, _Trivial>::copy(__first,
			__last, __result);
	}
	
	template <typename _BI1, typename _BI2>
	inline _BI2 __copy_backward_output_normal_iterator(_BI1 __first, _BI1 __last,
				_BI2 __result, __true_type)
	{ return _BI2(__copy_backward_aux(__first, __last, __result.base())); }
	
	template <typename _BI1, typename _BI2>
	inline _BI2 __copy_backward_output_normal_iterator(_BI1 __first, _BI1 __last,
						   _BI2 __result, __false_type)
	{ return __copy_backward_aux(__first, __last, __result); }
	
	template <typename _BI1, typename _BI2>
	inline _BI2 __copy_backward_input_normal_iterator(_BI1 __first, _BI1 __last,
						  _BI2 __result, __true_type) {
		typedef typename _Is_normal_iterator<_BI2>::_Normal __Normal;
		return __copy_backward_output_normal_iterator(__first.base(),
				__last.base(), __result, __Normal());
	}
	
	template <typename _BI1, typename _BI2>
	inline _BI2 __copy_backward_input_normal_iterator(_BI1 __first, _BI1 __last,
						  _BI2 __result, __false_type) {
		typedef typename _Is_normal_iterator<_BI2>::_Normal __Normal;
		return __copy_backward_output_normal_iterator(__first, __last,  __result, __Normal());
	}
	
	template <typename _BI1, typename _BI2>
	inline _BI2 copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) {
		typedef typename _Is_normal_iterator<_BI1>::_Normal __Normal;
		return __copy_backward_input_normal_iterator(__first, __last,
								__result, __Normal());
	}
	
	template<typename _RandomAccessIterator>
	void __insertion_sort(_RandomAccessIterator __first,
				 _RandomAccessIterator __last) {
		if (__first == __last) return;
	
		for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i) {
			typename iterator_traits<_RandomAccessIterator>::value_type
			  __val = *__i;
			if (__val < *__first) {
				copy_backward(__first, __i, __i + 1);
				*__first = __val;
			}
			else __unguarded_linear_insert(__i, __val);
		}
	}
	
	template<typename _RandomAccessIterator>
	inline void __unguarded_insertion_sort(_RandomAccessIterator __first,
			_RandomAccessIterator __last) {
		typedef typename iterator_traits<_RandomAccessIterator>::value_type
		  _ValueType;
	
		for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
			__unguarded_linear_insert(__i, _ValueType(*__i));
	}
	
	template<typename _RandomAccessIterator>
	void __final_insertion_sort(_RandomAccessIterator __first,
				   _RandomAccessIterator __last) {
		if (__last - __first > _S_threshold)
		{
			__insertion_sort(__first, __first + _S_threshold);
			__unguarded_insertion_sort(__first + _S_threshold, __last);
		}
		else __insertion_sort(__first, __last);
	}
	
	template<typename _RandomAccessIterator>
	inline void sort(_RandomAccessIterator __first,
			_RandomAccessIterator __last) {
		if (__first != __last) {
			__introsort_loop(__first, __last, __lg(__last - __first) * 2);
			__final_insertion_sort(__first, __last);
		}
	}
	
	template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
		typename _Compare>
	void __push_heap(_RandomAccessIterator __first, _Distance __holeIndex,
			_Distance __topIndex, _Tp __value, _Compare __comp) {
		_Distance __parent = (__holeIndex - 1) / 2;
		while (__holeIndex > __topIndex
			 && __comp(*(__first + __parent), __value)) {
			*(__first + __holeIndex) = *(__first + __parent);
			__holeIndex = __parent;
			__parent = (__holeIndex - 1) / 2;
		}
		*(__first + __holeIndex) = __value;
	}
	
	template<typename _RandomAccessIterator, typename _Compare>
	inline void push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
			  _Compare __comp) {
		typedef typename iterator_traits<_RandomAccessIterator>::value_type
		  _ValueType;
		typedef typename iterator_traits<_RandomAccessIterator>::difference_type
		  _DistanceType;
	
		__push_heap(__first, _DistanceType((__last - __first) - 1),
				   _DistanceType(0), _ValueType(*(__last - 1)), __comp);
	}
	
	template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
	void __push_heap(_RandomAccessIterator __first, _Distance __holeIndex,
			_Distance __topIndex, _Tp __value) {
		_Distance __parent = (__holeIndex - 1) / 2;
		while (__holeIndex > __topIndex && *(__first + __parent) < __value) {
			*(__first + __holeIndex) = *(__first + __parent);
			__holeIndex = __parent;
			__parent = (__holeIndex - 1) / 2;
		}
		*(__first + __holeIndex) = __value;
	}
	
	template<typename _RandomAccessIterator>
	void make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
	{
		typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
		typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType;
		  
		if (__last - __first < 2) return;
			
		const _DistanceType __len = __last - __first;
		_DistanceType __parent = (__len - 2) / 2;
		while (1) {
			__adjust_heap(__first, __parent, __len,
					 _ValueType(*(__first + __parent)));
			if (__parent == 0)
				return;
			__parent--;
		}
	}
	
	template<typename _RandomAccessIterator, typename _Distance,
		   typename _Tp, typename _Compare>
	void __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
			  _Distance __len, _Tp __value, _Compare __comp) {
		const _Distance __topIndex = __holeIndex;
		_Distance __secondChild = 2 * __holeIndex + 2;
		while (__secondChild < __len) {
			if (__comp(*(__first + __secondChild),
				 *(__first + (__secondChild - 1))))
				__secondChild--;
			*(__first + __holeIndex) = *(__first + __secondChild);
			__holeIndex = __secondChild;
			__secondChild = 2 * (__secondChild + 1);
		}
		if (__secondChild == __len) {
			*(__first + __holeIndex) = *(__first + (__secondChild - 1));
			__holeIndex = __secondChild - 1;
		}
		__push_heap(__first, __holeIndex, __topIndex, __value, __comp);
	}
	
	template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
	void __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
			_Distance __len, _Tp __value) {
		const _Distance __topIndex = __holeIndex;
		_Distance __secondChild = 2 * __holeIndex + 2;
		while (__secondChild < __len) {
			if (*(__first + __secondChild) < *(__first + (__secondChild - 1)))
				__secondChild--;
			*(__first + __holeIndex) = *(__first + __secondChild);
			__holeIndex = __secondChild;
			__secondChild = 2 * (__secondChild + 1);
		}
		if (__secondChild == __len) {
			*(__first + __holeIndex) = *(__first + (__secondChild - 1));
			__holeIndex = __secondChild - 1;
		}
		__push_heap(__first, __holeIndex, __topIndex, __value);
	}
	
	template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
	inline void __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
			   _RandomAccessIterator __result, _Tp __value, _Compare __comp) {
		typedef typename iterator_traits<_RandomAccessIterator>::difference_type
				_Distance;
		*__result = *__first;
		__adjust_heap(__first, _Distance(0), _Distance(__last - __first),
				 __value, __comp);
	}
	
	template<typename _RandomAccessIterator, typename _Tp>
	inline void __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
			   _RandomAccessIterator __result, _Tp __value) {
		typedef typename iterator_traits<_RandomAccessIterator>::difference_type _Distance;
		*__result = *__first;
		__adjust_heap(__first, _Distance(0), _Distance(__last - __first), __value);
	}
	
	template<typename _RandomAccessIterator>
	inline void pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) {
		typedef typename iterator_traits<_RandomAccessIterator>::value_type
		  _ValueType;
	
		__pop_heap(__first, __last - 1, __last - 1,
				_ValueType(*(__last - 1)));
	}
	
	template<typename _RandomAccessIterator>
	void sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) {
		while (__last - __first > 1) pop_heap(__first, __last--);
	}
	
	template<typename _RandomAccessIterator>
	void partial_sort(_RandomAccessIterator __first,
			 _RandomAccessIterator __middle,
			 _RandomAccessIterator __last) {
		typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
		make_heap(__first, __middle);
		for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
			if (*__i < *__first)
				__pop_heap(__first, __middle, __i, _ValueType(*__i));
		sort_heap(__first, __middle);
	}
	
	template<typename _RandomAccessIterator, typename _Size>
	void __introsort_loop(_RandomAccessIterator __first,
				 _RandomAccessIterator __last,
				 _Size __depth_limit) {
		typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
		while (__last - __first > _S_threshold) {
			if (__depth_limit == 0) {
				partial_sort(__first, __last, __last);
				return;
			}
			--__depth_limit;
			_RandomAccessIterator __cut =
			__unguarded_partition(__first, __last, _ValueType(__median(*__first, *(__first + (__last - __first) / 2), *(__last - 1))));
			__introsort_loop(__cut, __last, __depth_limit);
			__last = __cut;
		}
	}
}

int main() {
	int a[] = {2, 3, 4, 1, 5};
	std::sort(a, a+5);
	for(int i=0;i<5;i++)printf("%d ", a[i]);
	system("pause");
	return 0;
}


huanghongxun
关注
专栏目录
C++library Sort库排序的实现算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-19 587
C++library Sort库排序的实现算法C++library Sort库排序的实现算法完整源码(定义，实现，main函数测试） C++library Sort库排序的实现算法完整源码(定义，实现，main函数测试） #include <algorithm> #include <iostream> void librarySort(int *index, int n) { int lib_size, index_pos, *gaps, //
C++内存管理（建议收藏）
编程与实战的博客
07-21 5053
内存管理是C++最令人切齿痛恨的问题，也是C++最有争议的问题，C++高手从中获得了更好的性能，更大的自由，C++菜鸟的收获则是一遍一遍的检查代码和对C++的痛恨，但内存管理在C++中无处...
Sort_Algorithm_排序算法_C++_c++algorithmsort_
10-01
使用c++实现常见的排序算法，包括冒泡排序，快速排序，直接插入排序，带有完整注释
【算法】【C++】【Algorithm】sort函数介绍
weixin_43719890的博客
08-19 407
C++ sort函数用法介绍
c++结构体数组sort排序出错？（关于sort排序comp比较器的严格弱排序性质）
ylh的博客
12-31 2058
原因：参考cplusplus中对于comp比较规则的解析。严格弱排序：（a=50,b=60） a < b。再来比较这两个对象： （我们可以猜测出来，然后在我创建变量，并且输入进行排序后。即comp必须是一个。如何解决这个问题呢？
C++11: 内置函数 - min() 和 max()
fengbohello的专栏
12-28 3112
文件位置： /usr/include/c++/4.8.2/bits/stl_algobase.h 目录 一、min & max 定义 1.1）简单的比较两个对象的大小 1.2）传入 comp 函数 一、min & max 定义 1.1）简单的比较两个对象的大小 min(a, b) template<typename _Tp> inline const _Tp& min(const _Tp& __a, const _T..
CCF-CSP认证C++常用标准库函数
NoNameThinker的博客
12-13 4908
1、输入输出 2、字符串 3、数据结构 3.1 映射 3.1.1 map 头文件 #include <map> 3.1.1 unordered_map 3.2 集合 3.3 容器 4、映射 5、
C++ 2：短裤
qq_42347617的博客
05-08 989
C++ 短裤1. 引用1.1 定义1.2 应用：引用作为函数返回值1.3 常引用1.4 const 关键字2. 动态内存分配2.1 new运算符2.2 delete 运算符3. 内联函数 函数重载 函数缺省参数3.1 内联函数3.2 函数重载3.3 函数的缺省值类使用类的成员变量和成员函数 1. 引用 1.1 定义 r引用n，r等价与n（别名） r就是n，而不是n的副本，对r修改，n也跟着改变...
c++ list, vector, map, set 区别与用法比较
u010112268的博客
07-23 220
List封装了链表,Vector封装了数组, list和vector得最主要的区别在于vector使用连续内存存储的，他支持[]运算符，而list是以链表形式实现的，不支持[]。 Vector对于随机访问的速度很快，但是对于插入尤其是在头部插入元素速度很慢，在尾部插入速度很快。List对于随机访问速度慢得多，因为可能要遍历整个链表才能做到，但是对于插入就快的多了，不需要拷贝和移动数据，只需要改变...
《C++ Primer》学习笔记
风铃飞弦的博客
09-24 4398
第2章 变量和基本类型 什么是对象：内存中具有类型的区域。 初始化不是赋值：初始化指创建变量并给它赋初始值，而赋值则是擦除对象的当前值并用新值代替。 extern：当碰到它搞不清楚时，想一想声明和定义的关系，声明可以有多份，但定义必须有且只能有一份。 const 和 extern：定义全局变量时，隐式包含 extern，但如果还加了 const 的话（被限制了本文件使用），就要显示加上 ext...
STL::sort函数实现
weixin_30642305的博客
04-01 198
声明：本文参考链接：STL::sort实现。 排序是面试中经常被问及的算法基础知识点，虽然实际应用中不会直接使用，但是理解这些简单的算法知识对于更复杂更实用的算法有一定的帮助，毕竟面试总不能问的太过深入，那么这些知识点就显得很重要了。我们在程序中经常利用sort给序列排序，那么你知道它是什么实现的吗？ 函数声明 #include <algorithm> template...
C++[Error] '__comp' cannot be used as a function
热门推荐
yd_mmfly的博客
06-05 2万+
\dev-cpp\mingw32\lib\gcc\mingw32\4.7.2\include\c++\bits\stl_algobase.h [Error] '__comp' cannot be used as a function 我之所以会出现这个问题，是因为我把函数的定义的顺序写错了。 c、c++在编译的时候都是从上往下编译的，如果在前面没有声明一个函数名（或者是定义一个函数），在后...
C++ STL中的sort源码浅析
长期更新自学笔记
05-16 4118
文章目录元素少，使用插入排序递归次数过多，使用堆排序主体使用快速排序总结 首先提出几个问题： C++ STL默认提供以下两个sort接口 void std::sort(const _RanIt _First, const _RanIt _Last) void std::sort(const _RanIt _First, const _RanIt _Last, _Pr _Pred) 第一个函数的参数是排序区间，第二个函数的参数是排序区间和指定排序方式的函数对象 C++ STL默认使用less函数对象，进行
C++标准模板库之——sort函数
一点星光
01-12 957
C++ sort函数，小白请进，有帮助的哦~
C++ STL sort底层分析
BlackMonkeyHH的博客
01-14 1994
std：sort底层分析
谈谈c++中的萃取机制 traits
Dummkopfer的博客
05-13 553
template <class _Iterator> struct iterator_traits { typedef typename _Iterator::iterator_category iterator_category; typedef typename _Iterator::value_type value_type; typedef type...
知无涯之std::sort源码剖析
linux内核，glusterfs, 无人机，机器人
10-16 903
从事程序设计行业的朋友一定对排序不陌生，它从我们刚刚接触数据结构课程开始便伴随我们左右，是需要掌握的重要技能。任何一本数据结构的教科书一定会介绍各种各样的排序算法，比如最简单的冒泡排序、插入排序、希尔排序、堆排序等。在现已知的所有排序算法之中，快速排序名如其名，以快速著称，它的平均时间复杂度可以达到O(N logN)，是最快排序算法之一。 目录 背景Introspective Sort
<iostream><string> <algorithm>
最新发布
06-09
在C++编程中，`<iostream>`、`<string>`和`<algorithm>`是三个非常重要的头文件，它们分别对应不同的功能： 1. `<iostream>`：这是输入输出流（Input/Output Stream）库的简称，包含了基本的文本输入输出操作，如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值