能使用STL的sort系列算法的前提是容器的迭代器必须为随机迭代器。所以，vector和deque天然适用。STL的sort算法采用了一些策略，在不同情况下采用不同的排序算法，以达到各种算法优势互补的效果。基本的原则是：数据量大时采用快速排序，数据量小时采用插入排序（这是对快排常用的一种优化策略），递归层次过深改用堆排序。
首先是插入排序。它的平均和最坏时间复杂度都为O(N²)，量级小于千，那么插入排序还是一个不错的选择。SGI STL的插入排序默认以增序排列，另外还可以传入一个仿函数作为比较规则，这里只说明前者。
外层循环确定一个子区间，i位置的元素需要插入到已排序区间的正确位置上：
~~~
template <class RandomAccessIterator>
void __insertion_sort(RandomAccessIterator first, RandomAccessIterator last) {
if (first == last) return; // 容器为空，直接返回
for (RandomAccessIterator i = first + 1; i != last; ++i) // 确定子区间
__linear_insert(first, i, value_type(first));
}
~~~
进入__linear_insert函数：
~~~
template <class RandomAccessIterator, class T>
inline void __linear_insert(RandomAccessIterator first,
RandomAccessIterator last, T*) {
T value = *last; // 新插入元素
if (value < *first) { // 如果比已排序区间的第一个元素还要小
copy_backward(first, last, last + 1); // 使已排序区间整体后移一个位置
*first = value; // 新元素放在开头位置
}
else
__unguarded_linear_insert(last, value);
}
~~~
上面代码的注释已经说明了一种简单的情况，这是只需借用copy_backward算法将元素整体搬移，以腾出第一个位置给新插入元素。但其它情况下就要进入__unguarded_linear_insert函数了：
~~~
template <class RandomAccessIterator, class T>
void __unguarded_linear_insert(RandomAccessIterator last, T value) {
RandomAccessIterator next = last; // 指向新插入元素
--next; // 指向之前一个元素
while (value < *next) { // 发现逆转对
*last = *next; // 较大的元素往后走
last = next;
--next;
}
*last = value; // 新元素放入正确位置
}
~~~
上述函数的目标就是要找到value也就是新插入元素的正确插入位置。以value位置为起点，前向遍历已排序区间，遇到比value大的就后移一个位置，以消除逆转对的存在。注意，这里不需要进行越界判断，因为value肯定不会插入到区间头部。
当遇到大数据量时，效率为平方级的插入排序就不适用了。这时STL改用快速排序，平均效率为O(NlogN)，最坏效率为O(N²)。
快排首先要选取枢轴，STL采用的方法是选取前、中、后三点的中值作为枢轴。接下来是分割，遍历整个迭代器，小于枢轴的放左边，大于枢轴的放右边。具体做法如下：
- first迭代器向后移动，*first大于或等于枢轴时停止。
- last迭代器向前移动，*last小于或等于枢轴时停止。
- 若first仍在last的左边，则交换*first和*last，并调整两个迭代器指向下一个位置。
- 重复上述行为直到first和last交叉，first即为右半部分起始位置。
分割代码如下：
~~~
template <class RandomAccessIterator, class T> // 快排的分割函数
RandomAccessIterator __unguarded_partition(RandomAccessIterator first,
RandomAccessIterator last,
T pivot) {
while (true) {
while (*first < pivot) ++first; // 向后移动直到*first大于或等于枢轴
--last;
while (pivot < *last) --last; // 向前移动直到*last小于或等于枢轴
if (!(first < last)) return first; // 交叉后停止，返回的迭代器作为右子区间的开头
iter_swap(first, last); // 交换两个迭代器所指元素
++first;
}
}
~~~
现在来看看sort算法的对外接口：
~~~
template <class RandomAccessIterator>
inline void sort(RandomAccessIterator first, RandomAccessIterator last) {
if (first != last) {
__introsort_loop(first, last, value_type(first), __lg(last - first) * 2);
__final_insertion_sort(first, last);
}
}
~~~
要阅读__introsort_loop函数，先要了解introsort。以下是维基百科里的解释：
内省排序（英语：Introsort）是由David Musser在1997年设计的排序算法。这个排序算法首先从快速排序开始，当递归深度超过一定深度（深度为排序元素数量的对数值）后转为堆排序。采用这个方法，内省排序既能在常规数据集上实现快速排序的高性能，又能在最坏情况下仍保持O(nlogn)的时间复杂度。
个人理解，最坏情况发生在分割深度过深时，以中值作为枢轴的方法并不能选出合适的枢轴，导致分割时频繁地交换元素，使效率下降到O(N)。
上述代码中的__lg(last - first) * 2就是根据元素个数计算深度阈值，当分割深度超过阈值时，转而采用堆排序，是效率继续保持为O(nlogn)。
~~~
template <class Size>
inline Size __lg(Size n) { // 控制分割恶化的情况，求2^k <= n的最大k值
Size k;
for (k = 0; n != 1; n >>= 1) ++k;
return k;
}
~~~
例如，当元素个数为40时，最多允许分割10层。
有了上面内省排序的基础，下面的代码就很容易看了：
~~~
template <class RandomAccessIterator, class T, class Size>
void __introsort_loop(RandomAccessIterator first,
RandomAccessIterator last, T*,
Size depth_limit) {
while (last - first > __stl_threshold) { // 大于某个值才进行快速排序，这里__stl_threshold = 16
if (depth_limit == 0) {
partial_sort(first, last, last); // 分割恶化，采用堆排序
return;
}
--depth_limit;
RandomAccessIterator cut = __unguarded_partition
(first, last, T(__median(*first, *(first + (last - first)/2),
*(last - 1)))); // 采用三点中值作为枢轴进行快速排序
__introsort_loop(cut, last, value_type(first), depth_limit); // 对右半部分递归进行排序
last = cut; // 调整last位置，下一次while循环将对左半部分排序
}
}
~~~
partial_sort已经在另一篇文章中详细分析过了，实际上就是对整个区间进行堆排序。__median函数就是求取前、中、后三个元素中值作为枢轴，其它函数都已经在上面讲解过了。递归分段排序，典型的分治策略。当__introsort_loop函数返回时，要么完全已排序，要么大体已排序。大体已排序则要进行微调，即sort函数调用完__introsort_loop之后调用__final_insertion_sort进行微调：
~~~
template <class RandomAccessIterator>
void __final_insertion_sort(RandomAccessIterator first,
RandomAccessIterator last) {
if (last - first > __stl_threshold) { // 超过16个元素，则分割为两段
__insertion_sort(first, first + __stl_threshold); // 前段使用插入排序
__unguarded_insertion_sort(first + __stl_threshold, last); // 剩余元素逐个插入
}
else
__insertion_sort(first, last); // 元素个数不超过16，直接使用插入排序
}
~~~
注意，为了效率，STL又开始折腾了...，再进入__unguarded_insertion_sort瞧瞧：
~~~
template <class RandomAccessIterator, class T>
void __unguarded_insertion_sort_aux(RandomAccessIterator first,
RandomAccessIterator last, T*) {
for (RandomAccessIterator i = first; i != last; ++i)
__unguarded_linear_insert(i, T(*i)); // 将i所指元素插入已排序的16个元素的序列中，前面已经介绍过了
}
template <class RandomAccessIterator>
inline void __unguarded_insertion_sort(RandomAccessIterator first,
RandomAccessIterator last) {
__unguarded_insertion_sort_aux(first, last, value_type(first));
}
~~~
为什么要这样？当从__introsort_loop函数返回时，要么完全有序，要么大体有序。大体有序时，前面的子区间整体是要小于后面的子区间的，这是introsort操作之后的结果。在__final_insertion_sort中，如果元素个数超过16，先对前16个元素进行插入排序，后面剩下的元素再逐个插入到此有序区间。刚才说了由于已经是大体有序了，所以逐个插入操作不会出现过多的逆转对，这正是插入排序的优势所在。
至此，STL的sort算法分析完了。要读懂STL的心思确实不是意见容易的事情啊。
参考：
《STL源码剖析》 P389.
- 前言
- 顺序容器 — heap
- 关联容器 — 红黑树
- 关联容器 — set
- 关联容器 — map
- 关联容器 — hashtable
- 关联容器 — hash_set
- 关联容器 — hash_map
- 算法 — copy
- 顺序容器 — stack
- 顺序容器 — queue
- 顺序容器 — priority_queue
- 顺序容器 — slist
- construct()和destroy()
- 空间配置器
- 函数适配器
- 迭代器以及“特性萃取机”iterator_traits
- 算法 — partial_sort
- 算法 — sort
- 仿函数
- 适配器（adapters）
- C++简易vector
- C++简易list
- STL算法实现
- C++模板Queue