STL源码分析《3》----辅助空间不足时，如何进行归并排序

两个连在一起的序列 [first, middle) 和 [middle, last) 都已经排序，

归并排序最核心的算法就是 将 [first, middle) 和 [middle, last) 在 O(N)时间内合并成一个有序数组。

但是合并的过程中一般需要  m + n 的额外辅助空间。其中， m 、 n 是数组的左右半边的长度。

现在假如，

  1〉 辅助空间 bufSize < m + n 呢， 但是比 min(m, n) 大。也就是说能够容纳序列1 或者 序列 2。

  2〉 bufSize < min(m, n) 呢？？

  3〉假如没有辅助内存呢？？

STL implace_merge 函数在其实现中分别考虑了上述三种情况，并且尽可能地使效率比较高。

记号：长度为 m 的有序数组 A， 长度为 n 的有序数组 B， 

一、 buffer 能够容纳其中的一个有序数组

     1> 能够容纳 序列 1 [first, middle)

    

这时候只要先把 [first, middle) 拷贝到 [buffer, end_buffer) 中，

然后进行常规的 Merge, 依次将 [middle, last) 和 [buffer, end_buffer) 中小的元素放到 [first, last) 即可。不会存在数据覆盖的问题。

STL 源码如下：

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

copy(first, _middle, _buffer) 就是将 [first, middle) 复制到 buffer 中，

然后调用 STL 库的merge。

     2> 能够容纳 序列 2 [middle，last)

这时候将 [middle, last) 复制到 [buffer, end_buffer) 中，然后 逆向 merge 即可。

从两个序列的尾部向前，依次将大的元素放到数组的尾部。。

  else if (__len2 <= __buffer_size) {    _Pointer __buffer_end = copy(__middle, __last, __buffer);    __merge_backward(__first, __middle, __buffer, __buffer_end, __last);  }

template <class _BidirectionalIter1, class _BidirectionalIter2,          class _BidirectionalIter3, class _Compare>_BidirectionalIter3 __merge_backward(_BidirectionalIter1 __first1,                                     _BidirectionalIter1 __last1,                                     _BidirectionalIter2 __first2,                                     _BidirectionalIter2 __last2,                                     _BidirectionalIter3 __result,                                     _Compare __comp) {  if (__first1 == __last1)    return copy_backward(__first2, __last2, __result);  if (__first2 == __last2)    return copy_backward(__first1, __last1, __result);  --__last1;  --__last2;  while (true) {    if (__comp(*__last2, *__last1)) {      *--__result = *__last1;      if (__first1 == __last1)        return copy_backward(__first2, ++__last2, __result);      --__last1;    }    else {      *--__result = *__last2;      if (__first2 == __last2)        return copy_backward(__first1, ++__last1, __result);      --__last2;    }  }}

二、buffer 大小不足以容纳 [first, middle) 和 [middle，last)

上面的两种思路其实挺巧的，但是现在buffer 更小，怎么办？？

采取分治的思想，将问题的规模降下来，递归调用子问题，直到对于子问题，这个Buffer 大小足以容纳某一个有序序列。

我们的思路是：将数组分成  【1】  【2】  【3】  【4】 四个小数组。

                         交换 [2]  [3]，使得 【1 3】 作为新的子问题， 递归调用；

                                                       【2 4】作为新的子问题， 递归调用；

注意： 要使得最终数组有序，必须满足 【1 3】 中所有元素 <= 【2 4】中所有元素（这就是我们切数组时要满足的要求）

具体来说，

假如 [first, middle) 长度小于 [middle, last)。

STEP 1：

    我们拿长的序列开刀，对半开。

STEP 2:

   在对 [middle, first) 切时，要满足 数组 【3】 中元素 <= 数组【2】中的元素，

                                                                【2】中元素 <= 数组【4】中的元素

    Bingo, 其实只要在 [middle, last) 中 二分搜索【1】中最后一个元素 5。

STEP 3:

   将数组 【2】和数组【3】rotate 即可。

STEP 4：

  递归调用 【1】【3】， 和 【2】【4】；

直到 bufferSize >= 序列1或者序列2.

完整代码如下：

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);  }  else if (__len2 <= __buffer_size) {    _Pointer __buffer_end = copy(__middle, __last, __buffer);    __merge_backward(__first, __middle, __buffer, __buffer_end, __last);  }  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);  }}

参考资料：

侯捷， 《STL 源码分析》