C++STL sort源码分析

STL的sort算法：
当区间长度小于阈值（通常为5~20，STL取16）时，直接采用插入排序，因为插入排序的常系数比较小，数据量小时有不错的效果。

当区间长度大于阈值时，采用内省排序（IntroSort），其行为在大部分情况下几乎与三数取中quick sort完全相同。直到下面两种情况停止：

1. 当递归深度过深(递归深度>2*log2(len) )，意味着分割行为有恶化为二次行为的倾向时，能够自我侦测，转而改用Heap Sort,使效率维持在O(nlogn)。
2. 当区间长度小于阈值时，停止排序退出introsort调用，等待sort函数最后对大体已经有序的数组整体使用输入敏感的插入排序。

默认<版本，删去使用cmp重载部分源码：

//三数取中
template <class T>
inline const T& __median(const T& a, const T& b, const T& 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;
}

//partition函数
template <class RandomAccessIterator, class T>
RandomAccessIterator __unguarded_partition(RandomAccessIterator first,
                                           RandomAccessIterator last,
                                           T pivot) {
  while (true) {
    while (*first < pivot) ++first;
    --last;
    while (pivot < *last) --last;
    if (!(first < last)) return first;
    iter_swap(first, last);
    ++first;
  }
}

const int __stl_threshold = 16;//阈值设为16

//插入排序部分
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;
}

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);
}

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));
}

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));
}
 
template <class RandomAccessIterator>
inline void __unguarded_insertion_sort(RandomAccessIterator first,
                                RandomAccessIterator last) {
  __unguarded_insertion_sort_aux(first, last, value_type(first));
}

template <class RandomAccessIterator>
void __final_insertion_sort(RandomAccessIterator first,
                            RandomAccessIterator last) {
  if (last - first > __stl_threshold) {
    __insertion_sort(first, first + __stl_threshold);
    __unguarded_insertion_sort(first + __stl_threshold, last);
  }
  else
    __insertion_sort(first, last);
}

//递归深度限制选取
template <class Size>
inline Size __lg(Size n) {
  Size k;
  for (k = 0; n > 1; n >>= 1) ++k;
  return k;
}

//IntroSort
template <class RandomAccessIterator, class T, class Size>
void __introsort_loop(RandomAccessIterator first,
                      RandomAccessIterator last, T*,
                      Size depth_limit) {
  //区间长度小于阈值后，不再继续使用introsert，等最后插入排序
  while (last - first > __stl_threshold) {
    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;
  }
}

//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);
  }
}

参考：
《STL源码剖析》
https://blog.csdn.net/MDL13412/article/details/6660612