STL算法_sort算法篇

简介

sort算法接受两个randomaccessiterators（随机存取迭代器），然后将区间内的所有元素以渐增方式由小到大重新排序。stl中的关系型容器都拥有自动排序功能（底层使用rb-tree实现），不需要用到sort算法。至于序列式容器中的stack、queue和priority-queue都有特别的出入口，不允许用户对元素排序。剩下vector、deque和list，前者的迭代器属于randomaccessiterators，适合使用sort算法，list迭代器属于bidirectionaliterators，不在stl标准之列的slist，其迭代器更属于forwarditerators，都不适用于sort算法。如果要对list或slist排序，应该使用它们自己提供的member functions sort()。

排序在日常生活中非常重要。字典需要排序，书籍索引需要排序，磁盘目录需要排序，名片需要排序，馆藏需要排序，户籍数据需要排序。任何数据只要想快速查找，就需要排序。排序可以改善效率。

stl中的sort算法，数据量大时采用quick sort，分段递归排序，一旦分段后的数据量小于某个门槛，为避免quick sort的递归调用带来过大的额外负担，就改用insertion sort。如果递归层次过深，改用heap sort。stl中排序是使用quick sort和insertion sort完成的。

1）插入排序算法

insertion sort算法

以双层循环形式进行。外循环遍历整个序列，每次迭代决定出一个子区间；内循环遍历子区间内的每一个“逆转对”倒转过来。逆转对指任何两个迭代器i，j，i < j而*i > *j。一旦不存在逆转对，则排序完毕。时间复杂度为o(n^2)。数据量较少时效果比较好。stl中提供了两个版本实现。版本一：以渐增方式排序，即以operator<为两个元素的比较函数；版本二：允许用户指定一个仿函数，作为两元素的比较函数。

// 版本一辅助函数
// 此函数命名为unguarded_x原因：一般的insertion sort在内循环原本需要做两次判断，判断是否相邻两个元素是
// 逆转对，同时也判断循环是否超越边界。由于源码会导致最小值必然在内循环子区间的最边缘，所以两个判断合并
// 为一个判断，故称为unguarded_。
template 
void __unguarded_linear_insert(_randomaccessiter __last, _tp __val) {
  _randomaccessiter __next = __last;
  --__next;
  // insertion sort的内层循环
  // 注意：一旦不在出现逆转对，循环就可以结束
  while (__val < *__next) {   // 逆转对存在
    *__last = *__next;        // 调整
    __last = __next;          // 调整迭代器
    --__next;                 // 左移一个位置
  }
  *__last = __val;            // value的正确落脚处
}
// 版本2
template 
void __unguarded_linear_insert(_randomaccessiter __last, _tp __val, 
                               _compare __comp) {
  _randomaccessiter __next = __last;
  --__next;  
  while (__comp(__val, *__next)) {
    *__last = *__next;
    __last = __next;
    --__next;
  }
  *__last = __val;
}
// 版本一辅助函数
template 
inline void __linear_insert(_randomaccessiter __first, 
                            _randomaccessiter __last, _tp*) {
  _tp __val = *__last;                           // 记录尾元素
  if (__val < *__first) {                        // 尾比头还小（注意，头端必须为最小元素）
    // 那么就不用一个一个比较了，一次做完即可。
    copy_backward(__first, __last, __last + 1);  // 将整个区间向右递移一个位置
    *__first = __val;                            // 令头元素等于原先的尾元素值
  }
  else                                           // 尾不小于头
    __unguarded_linear_insert(__last, __val);
}
// 版本2
template 
inline void __linear_insert(_randomaccessiter __first, 
                            _randomaccessiter __last, _tp*, _compare __comp) {
  _tp __val = *__last;
  if (__comp(__val, *__first)) {
    copy_backward(__first, __last, __last + 1);
    *__first = __val;
  }
  else
    __unguarded_linear_insert(__last, __val, __comp);
}
// insertion sort算法：insertion sort以双层循环形式进行。外循环遍历整个序列，每次迭代决定出一个子区间；
// 内循环遍历子区间内的每一个“逆转对”倒转过来。逆转对指任何两个迭代器i，j，i*j。一旦不存在逆转对，
// 则排序完毕。时间复杂度为o(n^2)。数据量较少时效果比较好。stl中提供了两个版本实现。版本一：以渐增方式排
// 序，即以operator<为两个元素的比较函数；版本二：允许用户指定一个仿函数，作为两元素的比较函数。
// 版本一实现
template 
void __insertion_sort(_randomaccessiter __first, _randomaccessiter __last) {
  if (__first == __last) return; 
  for (_randomaccessiter __i = __first + 1; __i != __last; ++__i)   // 外循环
    // 以下，[first,i)形成一个子区间
    __linear_insert(__first, __i, __value_type(__first));
}
// 版本二实现
template 
void __insertion_sort(_randomaccessiter __first,
                      _randomaccessiter __last, _compare __comp) {
  if (__first == __last) return;
  for (_randomaccessiter __i = __first + 1; __i != __last; ++__i)
    __linear_insert(__first, __i, __value_type(__first), __comp);
}
template 
void __unguarded_insertion_sort_aux(_randomaccessiter __first, 
                                    _randomaccessiter __last, _tp*) {
  for (_randomaccessiter __i = __first; __i != __last; ++__i)
    __unguarded_linear_insert(__i, _tp(*__i));
}
template 
inline void __unguarded_insertion_sort(_randomaccessiter __first, 
                                _randomaccessiter __last) {
  __unguarded_insertion_sort_aux(__first, __last, __value_type(__first));
}
template 
void __unguarded_insertion_sort_aux(_randomaccessiter __first, 
                                    _randomaccessiter __last,
                                    _tp*, _compare __comp) {
  for (_randomaccessiter __i = __first; __i != __last; ++__i)
    __unguarded_linear_insert(__i, _tp(*__i), __comp);
}
template 
inline void __unguarded_insertion_sort(_randomaccessiter __first, 
                                       _randomaccessiter __last,
                                       _compare __comp) {
  __unguarded_insertion_sort_aux(__first, __last, __value_type(__first),
                                 __comp);
}

final_insertion_sort函数

此函数主要在排序算法达到基本有序后利用插入排序快速完成最终的排序

// final_insertion_sort函数，首先判断元素个数是否大于16。如果答案为否，就调用__insertion_sort()加以处理
// 如果答案为是，就将[first,last)分割为长度16的一段子序列，和另一段剩余子序列，再针对两个子序列分别调用
// __insertion_sort()和__ungurarded_insertion_sort()。
template 
void __final_insertion_sort(_randomaccessiter __first, 
                            _randomaccessiter __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 
void __final_insertion_sort(_randomaccessiter __first, 
                            _randomaccessiter __last, _compare __comp) {
  if (__last - __first > __stl_threshold) {
    __insertion_sort(__first, __first + __stl_threshold, __comp);
    __unguarded_insertion_sort(__first + __stl_threshold, __last, __comp);
  }
  else
    __insertion_sort(__first, __last, __comp);
}
// 找出2^k<=n的最大值k。例：n=7，得k=2，n=20，得k=4，n=8，得k=3
template 
inline _size __lg(_size __n) {
  _size __k;
  for (__k = 0; __n != 1; __n >>= 1) ++__k;
  return __k;
}

2）快速排序算法

quick sort算法是目前最快的排序算法，平均复杂度为o(nlogn），最坏情况下将达到o(n^2)。不过introsort（类似median-of-three quicksort的一种排序算法）可将最坏情况推进到o(nlogn）。

quick sort算法叙述如下。假设s代表将被处理的序列：1）如果s的元素个数为0或1，结束；2）取s中的任何一个元素，当做枢轴（pivot）v；3）将s分割为l，r两段，使l内的每个元素都小于或等于v，r内的每一个元素都大于或等于v；4）对l，r递归执行quick sort。

quick sort精神在于将大区间分割为小区间，分段排序。每一个小区间排序完成后，串接起来的大区间也就完成了排序。最坏情况发生在分割时产生出一个空的子区间——那完全没有达到分割的预期效果。

median-of-three（三点中值算法）

注意，任何一个元素都可以被选来当做枢轴，但是其合适与否却会影响quick sort的效率。为避免“元素当初输入时不够随机”所带来的恶化效应，最理想最稳当的方式就是取整个序列的头、尾、*三个位置，以其中值作为枢轴。成为median-of-three partitioning或median-of-three quick sort。为了能够快速取出*位置的元素，显然迭代器必须能够随机定位，即必为randomaccessiterators。

// median-of-three（三点中值）：注意，任何一个元素都可以被选来当做枢轴，但是其合适与否却会影响
// quick sort的效率。为避免“元素当初输入时不够随机”所带来的恶化效应，最理想最稳当的方式就是取整
// 个序列的头、尾、*三个位置，以其中值作为枢轴。成为median-of-three partitioning或median-of-three
// quick sort。为了能够快速取出*位置的元素，显然迭代器必须能够随机定位，即必为randomaccessiterators。
// 版本1
template 
inline const _tp& __median(const _tp& __a, const _tp& __b, const _tp& __c) {
  __stl_requires(_tp, _lessthancomparable);
  if (__a < __b)
    if (__b < __c)            // a < b < c
      return __b;
    else if (__a < __c)       // a < b, b >= c, a < c
      return __c;
    else
      return __a;
  else if (__a < __c)         // c > a >= b
    return __a;
  else if (__b < __c)         // a >= b, a >= c, b < c
    return __c;
  else
    return __b;
}
// 版本2
template 
inline const _tp&
__median(const _tp& __a, const _tp& __b, const _tp& __c, _compare __comp) {
  __stl_binary_function_check(_compare, bool, _tp, _tp);
  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;
}

partitioning（分割）算法

即令头迭代器first向尾部移动，尾端迭代器last向头部移动。当*first大于或等于枢轴时就停下来，当*last小于或等于枢轴时也停下来，然后检验两个迭代器是否交错。如果first仍然在左而last仍然在右，就将两者元素互换，然后各自调整一个位置（向*逼近），再继续进行相同的行为。如果发现两个迭代器交错了（即!(first < last)），表示整个序列已经调整完毕，此时的first为轴，将序列分为左右两半，左半部分所有元素都小于等于枢轴，右半部分所有元素值都大于等于枢轴。

// 分割算法，主要使快排算法每次能够稳定分割，主要作为辅助函数
// forwarditer版本
template 
_forwarditer __partition(_forwarditer __first,
                 _forwarditer __last,
             _predicate   __pred,
             forward_iterator_tag) {
  if (__first == __last) return __first;      // 头指针等于为指针，所有操作结束

  while (__pred(*__first))
    if (++__first == __last) return __first;  // 头指针等于为指针，所有操作结束

  _forwarditer __next = __first;

  while (++__next != __last)
    if (__pred(*__next)) {
      swap(*__first, *__next);
      ++__first;
    }

  return __first;
}
// bidirectionaliter版本
template 
_bidirectionaliter __partition(_bidirectionaliter __first,
                               _bidirectionaliter __last,
                   _predicate __pred,
                   bidirectional_iterator_tag) {
  while (true) {
    while (true)
      if (__first == __last)        // 头指针等于尾指针
        return __first;             // 所有操作结束
      else if (__pred(*__first))    // 头指针所指的元素符合不移动条件
        ++__first;                  // 不移动，头指针前进1
      else                          // 头指针符合元素移动条件
        break;                      // 跳出循环
    --__last;                       // 尾指针回溯1
    while (true)
      if (__first == __last)        // 头指针等于尾指针
        return __first;             // 所有操作结束
      else if (!__pred(*__last))    // 尾指针所指的元素符合不移动条件
        --__last;                   // 不移动，尾指针回溯1
      else                          // 尾指针所指元素符合移动条件
        break;                      // 跳出循环
    iter_swap(__first, __last);     // 头尾指针所指元素彼此交换
    ++__first;                      // 头指针前进1，准备下一个外循环迭代
  }
}
// randomaccessiter版本
template 
_randomaccessiter __unguarded_partition(_randomaccessiter __first, 
                                        _randomaccessiter __last, 
                                        _tp __pivot) 
{
  while (true) {
    while (*__first < __pivot)    // first找到>=pivot的元素就停下来
      ++__first;
    --__last;                     // 调整
    while (__pivot < *__last)     // last找到<=pivot的元素就停下来
      --__last;
    // 注意，以下first
inline _forwarditer partition(_forwarditer __first,
                  _forwarditer __last,
                  _predicate   __pred) {
  __stl_requires(_forwarditer, _mutable_forwarditerator);
  __stl_unary_function_check(_predicate, bool, 
        typename iterator_traits<_forwarditer>::value_type);
  return __partition(__first, __last, __pred, __iterator_category(__first));
}

introsort算法

insertion sort在面对几近排序的序列时，表现出很好的排序功能，效果更好。sort算法中，使用混合排序算法：introspective sorting（内省式排序）introsort，其行为大部分情况下与median-of-3 quick sort完全相同，但是当分割行为有恶化为二次行为的倾向时，能够自我侦测，转为heap sort，使效率维持在heap sort的o(nlogn），又比一开始使用heap sort效果好。

// insertion sort算法：insertion sort以双层循环形式进行。外循环遍历整个序列，每次迭代决定出一个子区间；
// 内循环遍历子区间内的每一个“逆转对”倒转过来。逆转对指任何两个迭代器i，j，i*j。一旦不存在逆转对，
// 则排序完毕。时间复杂度为o(n^2)。数据量较少时效果比较好。stl中提供了两个版本实现。版本一：以渐增方式排
// 序，即以operator<为两个元素的比较函数；版本二：允许用户指定一个仿函数，作为两元素的比较函数。
// 版本一实现
template 
void __insertion_sort(_randomaccessiter __first, _randomaccessiter __last) {
  if (__first == __last) return; 
  for (_randomaccessiter __i = __first + 1; __i != __last; ++__i)   // 外循环
    // 以下，[first,i)形成一个子区间
    __linear_insert(__first, __i, __value_type(__first));
}
// 版本二实现
template 
void __insertion_sort(_randomaccessiter __first,
                      _randomaccessiter __last, _compare __comp) {
  if (__first == __last) return;
  for (_randomaccessiter __i = __first + 1; __i != __last; ++__i)
    __linear_insert(__first, __i, __value_type(__first), __comp);
}
// 当元素个数为40时，__introsoft_loop()的最后一个参数将是5*2，意思是最多允许分割10层。
// 版本一：本函数内的许多迭代器运算操作，都只适用于randomaccess iterators
template 
void __introsort_loop(_randomaccessiter __first,
                      _randomaccessiter __last, _tp*,
                      _size __depth_limit)
{
  // 以下，__stl_threshold是个全局常数，稍早定义const int 16
  while (__last - __first > __stl_threshold) {    // >16
    if (__depth_limit == 0) {                     // 至此，分割恶化
      partial_sort(__first, __last, __last);      // 改用heapsort
      return;
    }
    --__depth_limit;
    // 以下是median-of-3 partition，选择一个够好的枢轴并决定分割点
    // 分割点将落在迭代器cut身上
    _randomaccessiter __cut =
      __unguarded_partition(__first, __last,
                            _tp(__median(*__first,
                                         *(__first + (__last - __first)/2),
                                         *(__last - 1))));
    // 对右半段递归进行sort
    __introsort_loop(__cut, __last, (_tp*) 0, __depth_limit);
    __last = __cut;
    // 现在回到while循环，准备对左半段递归进行sort
    // 这种写法可读性较差，效率并没有比较好
  }
}
// 版本2
template 
void __introsort_loop(_randomaccessiter __first,
                      _randomaccessiter __last, _tp*,
                      _size __depth_limit, _compare __comp)
{
  while (__last - __first > __stl_threshold) {
    if (__depth_limit == 0) {
      partial_sort(__first, __last, __last, __comp);
      return;
    }
    --__depth_limit;
    _randomaccessiter __cut =
      __unguarded_partition(__first, __last,
                            _tp(__median(*__first,
                                         *(__first + (__last - __first)/2),
                                         *(__last - 1), __comp)),
       __comp);
    __introsort_loop(__cut, __last, (_tp*) 0, __depth_limit, __comp);
    __last = __cut;
  }
}

3）sort算法

stl中的sort算法前面主要利用introsort算法，最后使用insertsort算法。

// stl中sort算法
// 版本1
template 
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);
  }
}
// 版本2
template 
inline void sort(_randomaccessiter __first, _randomaccessiter __last,
                 _compare __comp) {
  __stl_requires(_randomaccessiter, _mutable_randomaccessiterator);
  __stl_binary_function_check(_compare, bool,
       typename iterator_traits<_randomaccessiter>::value_type,
       typename iterator_traits<_randomaccessiter>::value_type);
  if (__first != __last) {
    __introsort_loop(__first, __last,
                     __value_type(__first),
                     __lg(__last - __first) * 2,
                     __comp);
    __final_insertion_sort(__first, __last, __comp);
  }
}