STL 排序算法实现
C++ STL中提供了不少和排序相关的算法，包括堆排序(heap_sort)、排序(sort)、稳定排序(stable_sort)、局部排序(partial_sort)，时间复杂度均为O(nlogn)。其中，对于堆排序，也提供了不少函数，像入堆push_heap、创建堆make_heap、出堆pop_heap，是否为堆is_heap等。首先要明确数据结构上堆的概念。对于一个迭代器区间上的元素，不管实际的数据结构如何，都可以逻辑上排成一个完全二叉树，如果树的每个父节点都不小于左右两个子节点，那么区间元素就构成了一个堆。
STL实现：
建堆：make_heap(_First, _Last, _Comp)
默认是建立最大堆的。对int类型，可以在第三个参数传入greater<int>()得到最小堆。
template <class RandomAccessIterator> void make_heap (RandomAccessIterator first, RandomAccessIterator last); template <class RandomAccessIterator, class Compare> void make_heap (RandomAccessIterator first, RandomAccessIterator last, Compare comp );
template <class RandomAccessIterator> void push_heap (RandomAccessIterator first, RandomAccessIterator last); template <class RandomAccessIterator, class Compare> void push_heap (RandomAccessIterator first, RandomAccessIterator last, Compare comp);
在堆中添加数据：push_heap (_First, _Last)
要先在容器中加入数据，再调用push_heap ()
在堆中删除数据：pop_heap(_First, _Last)
要先调用pop_heap()再在容器中删除数据
template <class RandomAccessIterator> void push_heap (RandomAccessIterator first, RandomAccessIterator last); template <class RandomAccessIterator, class Compare> void push_heap (RandomAccessIterator first, RandomAccessIterator last, Compare comp);
堆排序：sort_heap(_First, _Last)
排序之后就不再是一个合法的heap了
注意：sort_heap 第三个参数必须和堆结构对应，否则会出现错误！！比如为最小堆时，sort_heap参数必须为greater<int>()，得到的排序为从大到小；为最大堆时，参数缺省或者为less<int>()，得到的排序为从小到大。这是因为sort_heap实际就是一直在做pop，把堆顶的元素交换到最后。
#include<iostream> #include<algorithm> #include<functional> #include<vector> using namespace std; void printItem(vector<int> items) { for(vector<int>::iterator it = items.begin(); it != items.end(); ++it) cout<<*it<<" "; cout<<endl; } int main() { //freopen("input.txt","r",stdin); //freopen("output.txt","w",stdout); int numbers[] = {5,6,22,33,4,1,7,12,8,13}; vector<int> items(numbers, numbers + 10); cout<<"---------make heap-----------"<<endl; make_heap(items.begin(), items.end(), greater<int>());//第三个参数缺省或者是less<int>()时 为最大堆 printItem(items); cout<<"---------push heap-----------"<<endl; items.push_back(0); push_heap(items.begin(), items.end(), greater<int>()); printItem(items); cout<<"---------pop heap-----------"<<endl; pop_heap(items.begin(), items.end(), greater<int>()); items.pop_back(); printItem(items); cout<<"---------sort heap-----------"<<endl; sort_heap(items.begin(), items.end(), greater<int>()); printItem(items); return 0; }
函数声明
#include <algorithm> template< class RandomIt > void sort( RandomIt first, RandomIt last ); template< class RandomIt, class Compare > void sort( RandomIt first, RandomIt last, Compare comp );
使用方法非常简单，STL提供了两种调用方式，一种是使用默认的<操作符比较，一种可以自定义比较函数。可是为什么它通常比我们自己写的排序要快那么多呢？
实现原理
原来，STL中的sort并非只是普通的快速排序，除了对普通的快速排序进行优化，它还结合了插入排序和堆排序。根据不同的数量级别以及不同情况，能自动选用合适的排序方法。当数据量较大时采用快速排序，分段递归。一旦分段后的数据量小于某个阀值，为避免递归调用带来过大的额外负荷，便会改用插入排序。而如果递归层次过深，有出现最坏情况的倾向，还会改用堆排序。
普通的快速排序
普通快速排序算法可以叙述如下，假设S代表需要被排序的数据序列：
- 如果
S中的元素只有0个或1个，结束。 - 取
S中的任何一个元素作为枢轴pivot。 - 将
S分割为L、R两端，使L内的元素都小于等于pivot，R内的元素都大于等于pivot。 - 对
L、R递归执行上述过程。
快速排序最关键的地方在于枢轴的选择，最坏的情况发生在分割时产生了一个空的区间，这样就完全没有达到分割的效果。STL采用的做法称为median-of-three，即取整个序列的首、尾、中央三个地方的元素，以其中值作为枢轴。
分割的方法通常采用两个迭代器head和tail，head从头端往尾端移动，tail从尾端往头端移动，当head遇到大于等于pivot的元素就停下来，tail遇到小于等于pivot的元素也停下来，若head迭代器仍然小于tail迭代器，即两者没有交叉，则互换元素，然后继续进行相同的动作，向中间逼近，直到两个迭代器交叉，结束一次分割。
看一张来自维基百科上关于快速排序的动态图片，帮助理解。
内省式排序 Introsort
不当的枢轴选择，导致不当的分割，会使快速排序恶化为 O(n2)。David R.Musser于1996年提出一种混合式排序算法：Introspective Sorting（内省式排序），简称IntroSort，其行为大部分与上面所说的median-of-three Quick Sort完全相同，但是当分割行为有恶化为二次方的倾向时，能够自我侦测，转而改用堆排序，使效率维持在堆排序的 O(nlgn)，又比一开始就使用堆排序来得好。
代码分析
下面是完整的SGI STL sort()源码（使用默认<操作符版）
template <class _RandomAccessIter>
inline void sort(_RandomAccessIter __first, _RandomAccessIter __last) {
__STL_REQUIRES(_RandomAccessIter, _Mutable_RandomAccessIterator);
__STL_REQUIRES(typename iterator_traits<_RandomAccessIter>::value_type,
_LessThanComparable);
if (__first != __last) {
__introsort_loop(__first, __last,
__VALUE_TYPE(__first),
__lg(__last - __first) * 2);
__final_insertion_sort(__first, __last);
}
}其中，__introsort_loop便是上面介绍的内省式排序，其第三个参数中所调用的函数__lg()便是用来控制分割恶化情况，代码如下：
template <class Size>
inline Size __lg(Size n) {
Size k;
for (k = 0; n > 1; n >>= 1) ++k;
return k;
}即求lg(n)（取下整），意味着快速排序的递归调用最多 2*lg(n) 层。
内省式排序算法如下：
template <class _RandomAccessIter, class _Tp, class _Size>
void __introsort_loop(_RandomAccessIter __first,
_RandomAccessIter __last, _Tp*,
_Size __depth_limit)
{
while (__last - __first > __stl_threshold) {
if (__depth_limit == 0) {
partial_sort(__first, __last, __last);
return;
}
--__depth_limit;
_RandomAccessIter __cut =
__unguarded_partition(__first, __last,
_Tp(__median(*__first,
*(__first + (__last - __first)/2),
*(__last - 1))));
__introsort_loop(__cut, __last, (_Tp*) 0, __depth_limit);
__last = __cut;
}
}- 首先判断元素规模是否大于阀值
__stl_threshold，__stl_threshold是一个常整形的全局变量，值为16，表示若元素规模小于等于16，则结束内省式排序算法，返回sort函数，改用插入排序。 - 若元素规模大于
__stl_threshold，则判断递归调用深度是否超过限制。若已经到达最大限制层次的递归调用，则改用堆排序。代码中的partial_sort即用堆排序实现。 -
若没有超过递归调用深度，则调用函数
__unguarded_partition()对当前元素做一趟快速排序，并返回枢轴位置。__unguarded_partition()函数采用的便是上面所讲的使用两个迭代器的方法，代码如下：template <class _RandomAccessIter, class _Tp> _RandomAccessIter __unguarded_partition(_RandomAccessIter __first, _RandomAccessIter __last, _Tp __pivot) { while (true) { while (*__first < __pivot) ++__first; --__last; while (__pivot < *__last) --__last; if (!(__first < __last)) return __first; iter_swap(__first, __last); ++__first; } } -
经过一趟快速排序后，再递归对右半部分调用内省式排序算法。然后回到while循环，对左半部分进行排序。源码写法和我们一般的写法不同，但原理是一样的，需要注意。
递归上述过程，直到元素规模小于__stl_threshold，然后返回sort函数，对整个元素序列调用一次插入排序，此时序列中的元素已基本有序，所以插入排序也很快。至此，整个sort函数运行结束。
