C++编程之stable_sort

一、sort()的潜在隐患

sort()最坏情况的改进

---

快速排序有着O(NlgN)的平均时间复杂度，如果遇到极端的情况可能会恶化到N^2。
但是在STL中，已经针对快速排序可能出现：
（1）pivot选取不当;
（2）递归深度过深;
两个问题分别给出了：
（1）三中值法：保证pivot选取合适;
（2）递归深度判断，过深直接堆排序。
将快速排序基本保持在了O(NlgN)，有效地避免了最坏情况地发生。

---

但是仔细分析源码，下面是分割的具体实现：

 while (*__first < __pivot)//当左值小于pivot，f向后移动，当左值大于等于pivot，停止
      ++__first;
    --__last;
    while (__pivot < *__last)////当右值大于pivot，l向前移动，当右值小于等于pivot，停止
      --__last;
    if (!(__first < __last))//如果两个指针接错，循环停止
      return __first;
    iter_swap(__first, __last);//否则交换
    ++__first;//指针向后移动一格

两个while分别用<和>进行了判断，

注意》》》》》如果此时first和last的值都等于pivot，那么两者仍然需要进行交换，当然两个相等的值交换并不影响什么，但是如果值还附带不同的属性呢，然后属性和值一同打包为一个对象，显然我们还是希望每次排序都是一样的。

这就是快速排序的不稳定的问题，为此STL中还有稳定版的sort。

---

二、stable_sort

快速排序不稳定，如果想要稳定的排序就换一种排序方式。

在STL中的其实就是归并排序，但是归并排序由于需要额外的数组来执行归并，所以如果没有足够的空间是不能正常归并的，STL是这样实现的：

template <class _RandomAccessIter, class _Tp, class _Distance, class _Compare>
inline void __stable_sort_aux(_RandomAccessIter __first, _RandomAccessIter __last, _Tp*, _Distance*,_Compare __comp) {
  _Temporary_buffer<_RandomAccessIter, _Tp> buf(__first, __last);//开辟一个缓冲数组
  if (buf.begin() == 0)//开辟失败了
    __inplace_stable_sort(__first, __last, __comp);//调用内部归并
  else 
    __stable_sort_adaptive(__first, __last, buf.begin(),_Distance(buf.size()), __comp);//有足够的空间，执行归并。时间复杂度在O(NlgN)
}

1、先看正常的有足够空间的归并吧：

首先，考虑的是数组我是申请了，但是万一不够大呢，于是就递归啊，直到大小合适了。

template <class _RandomAccessIter, class _Pointer, class _Distance, 
          class _Compare>
void __stable_sort_adaptive(_RandomAccessIter __first, _RandomAccessIter __last, _Pointer __buffer, _Distance __buffer_size, _Compare __comp) {
  _Distance __len = (__last - __first + 1) / 2;
  _RandomAccessIter __middle = __first + __len;
  if (__len > __buffer_size) {//判断缓冲的数组是否足够使用
    __stable_sort_adaptive(__first, __middle, __buffer, __buffer_size, __comp);//递归，将数组变小
    __stable_sort_adaptive(__middle, __last, __buffer, __buffer_size,  __comp);
  }
  else {
        __merge_sort_with_buffer(__first, __middle, __buffer, (_Distance*)0, __comp);//递归划分左边
    __merge_sort_with_buffer(__middle, __last, __buffer, (_Distance*)0,__comp);//划分右边
  }
  __merge_adaptive(__first, __middle, __last, _Distance(__middle - __first), _Distance(__last - __middle), __buffer, __buffer_size,__comp);//合并左右两边
}

现在，终于向CPU申请了足够大的内存空间，开始进入merge正题：

 __merge_sort_with_buffer

和一般的归并递归实现不一样，这里在底层用了插入排序。

template <class _RandomAccessIter, class _Pointer, class _Distance,class _Compare>

void __merge_sort_with_buffer(_RandomAccessIter __first, _RandomAccessIter __last, _Pointer __buffer,_Distance*, _Compare __comp) {
  _Distance __len = __last - __first;
  _Pointer __buffer_last = __buffer + __len;

  _Distance __step_size = __stl_chunk_size;
  __chunk_insertion_sort(__first, __last, __step_size, __comp);//先调用chunk_insertion_sort对每个长度为_S_chunk_size的子区间进行插入排序。

  while (__step_size < __len) {
    __merge_sort_loop(__first, __last, __buffer, __step_size, __comp);//
    __step_size *= 2;
    __merge_sort_loop(__buffer, __buffer_last, __first, __step_size, __comp);
    __step_size *= 2;
  }
}

先调用chunk_insertion_sort对每个长度为_S_chunk_size的子区间进行插入排序。

 __chunk_insertion_sort(__first, __last, __chunk_size)
{
  while (__last - __first >= __chunk_size) {
    __insertion_sort(__first, __first + __chunk_size);
    __first += __chunk_size;
  }
  __insertion_sort(__first, __last);
} 

合并已经插入排序好的分片

template <class _RandomAccessIter1, class _RandomAccessIter2,class _Distance, class _Compare>
void __merge_sort_loop(_RandomAccessIter1 __first,
                       _RandomAccessIter1 __last, 
                       _RandomAccessIter2 __result, _Distance __step_size,_Compare __comp) {
  _Distance __two_step = 2 * __step_size;

  while (__last - __first >= __two_step) {
    __result = merge(__first, __first + __step_size,__first + __step_size, __first + __two_step,__result,__comp);
    __first += __two_step;
  }
  __step_size = min(_Distance(__last - __first), __step_size);

  merge(__first, __first + __step_size,__first + __step_size, __last,__result,__comp);
}

其中的merge就比较正常了：

template <class _InputIter1, class _InputIter2, class _OutputIter>
_OutputIter merge(_InputIter1 __first1, _InputIter1 __last1,_InputIter2 __first2, _InputIter2 __last2,
_OutputIter __result) {
  __STL_REQUIRES(_InputIter1, _InputIterator);
  __STL_REQUIRES(_InputIter2, _InputIterator);
  __STL_REQUIRES(_OutputIter, _OutputIterator);
  __STL_REQUIRES_SAME_TYPE(
          typename iterator_traits<_InputIter1>::value_type,
          typename iterator_traits<_InputIter2>::value_type);
  __STL_REQUIRES(typename iterator_traits<_InputIter1>::value_type,
                 _LessThanComparable);
  while (__first1 != __last1 && __first2 != __last2) {
    if (*__first2 < *__first1) {
      *__result = *__first2;
      ++__first2;
    }
    else {
      *__result = *__first1;
      ++__first1;
    }
    ++__result;
  }
  return copy(__first2, __last2, copy(__first1, __last1, __result));
}

现在可以先总结一下：

首先如果数组nums的长度为len，首尾指针为left，right;

（1）首先，先判断是否有足够的缓冲数组产生;

假设有足够内存空间，那么就将nums从中间分块，划分为左右两块，每块上len/2，然后进入__merge_sort_with_buffer;

（2）对每一块以step_size又进行划分，并且调用插入排序，对每一分区进行排序;

len/2 = step_size+step_size+…….+ residual;

此时该原本长度为len/2的数组被划分为若干step_size大小以及余数的有序分区。

（3）先是同样都是step_size大小的有序数组进行归并，然后再与可能的余数部分进一步归并。最开始分得左右两边都已经是有序数组了。

开始合并最后的有序数组：

template <class _BidirectionalIter, class _Distance, class _Pointer>
void __merge_adaptive(_BidirectionalIter __first,
                      _BidirectionalIter __middle, 
                      _BidirectionalIter __last,
                      _Distance __len1, _Distance __len2,
                      _Pointer __buffer, _Distance __buffer_size) {
  if (__len1 <= __len2 && __len1 <= __buffer_size) {//如果缓冲数组足够大
    _Pointer __buffer_end = copy(__first, __middle, __buffer);//将前半部分复制到缓冲数组上
    merge(__buffer, __buffer_end, __middle, __last, __first);//合并到first
  }
  else if (__len2 <= __buffer_size) {
    _Pointer __buffer_end = copy(__middle, __last, __buffer);
    __merge_backward(__first, __middle, __buffer, __buffer_end, __last);//__merge_backward与std::merge类似
  }
  else {//如果缓冲数组不够大怎么办
    _BidirectionalIter __first_cut = __first;
    _BidirectionalIter __second_cut = __middle;
    _Distance __len11 = 0;
    _Distance __len22 = 0;
    if (__len1 > __len2) {
      __len11 = __len1 / 2;
      advance(__first_cut, __len11);
      __second_cut = lower_bound(__middle, __last, *__first_cut);
      distance(__middle, __second_cut, __len22); 
    }
    else {
      __len22 = __len2 / 2;
      advance(__second_cut, __len22);
      __first_cut = upper_bound(__first, __middle, *__second_cut);
      distance(__first, __first_cut, __len11);
    }
    _BidirectionalIter __new_middle =
      __rotate_adaptive(__first_cut, __middle, __second_cut, __len1 - __len11, __len22, __buffer, __buffer_size);
    __merge_adaptive(__first, __first_cut, __new_middle, __len11,__len22, __buffer, __buffer_size);//递归处理
    __merge_adaptive(__new_middle, __second_cut, __last, __len1 - __len11,__len2 - __len22, __buffer, __buffer_size);
  }
}