stl中list的sort算法实现

STL中有一个std::sort算法，但它是不支持std::list的，因为list不提供RandomIterator的支持，但list自己提供了sort算法，把list的元素按从小到大的方式来排序，代码长度到不长，但真是难以读懂，后来扣持了一下午终于搞明白了，贴个总结上来。

list::sort的代码如下（sgi stl）：

[cpp]  view plain  copy

1. template <class _Tp, class _Alloc>  
2. void list<_Tp, _Alloc>::sort()  
3. {  
4.     // Do nothing if the list has length 0 or 1.  
5.     if (_M_node->_M_next != _M_node && _M_node->_M_next->_M_next != _M_node) {  
6.         list<_Tp, _Alloc> __carry;  
7.         list<_Tp, _Alloc> __counter[64];  
8.         int __fill = 0;  
9.         while (!empty()) {  
10.             __carry.splice(__carry.begin(), *this, begin());  
11.             int __i = 0;  
12.             while(__i < __fill && !__counter[__i].empty()) {  
13.                 __counter[__i].merge(__carry);  
14.                 __carry.swap(__counter[__i++]);  
15.             }  
16.             __carry.swap(__counter[__i]);        
17.             if (__i == __fill) ++__fill;  
18.         }   
19.         for (int __i = 1; __i < __fill; ++__i)  
20.             __counter[__i].merge(__counter[__i-1]);  
21.         swap(__counter[__fill-1]);  
22.     }  
23. }  

行数的确不多，但还真麻烦，我先说一下他是怎么实现的，但具体为什么这么做，我不知道。

比如我们的list里有如下几个需要排序的元素：21，45，1，30，52，3，58，47，22，59，0，58。

排序的时候怎么做，我们先定义若干中转list在上述代码中定义了64个元素的数组

list<_Tp, _Alloc> __counter[64]; 其中里边存什么呢？他们都是用来中转用的

__counter[0]里存放2(0+1)次方个元素
__counter[1]里存放2(1+1)次方个元素
__counter[2]里存放2(2+1)次方个元素
__counter[3]里存放2(3+1)次方个元素，依次类推

 

那又是怎么个存放方法呢？一个指导原则就是当 第i个元素即__counter[i]的内容个数等于2 ⁽ⁱ⁺¹⁾ 次方时，就要把__counter[i]的数据转移给__count[i+1]。

具体过程如下：

取出第1个数21，放到__counter[0]里，这时__counter[0]里有一个元素，小于2，继续

__counter[0]: 21

__counter[1]: NULL

取出第2个数45，放到__counter[0]里(不是简单的放，而是排序放，类似两个list做merge)，这时__counter[0]里有2个元素了，需要把这两个元素转移到__counter[1].

__counter[0]: NULL

__counter[1]: 21,45

取出第3个数1，放到__counter[0]里，__count[0]与__count[1]都小于规定个数

__counter[0]: 1

__counter[1]: 21,45

取出第4个数30，放到__counter[0]里，这时__counter[0]的个数等于2了，需要转移到__counter[1]里

__counter[0]: NULL

__counter[1]: 1,21,30,45

但这时__counter[1]里的个数又等于4了，所有需要把__counter[1]的值转移到__counter[2]里，

__counter[0]: NULL

__counter[1]: NULL

__counter[2]: 1,21,30,45

然后取出52，放入__counter[0]

__counter[0]: 52

__counter[1]: NULL

__counter[2]: 1,21,30,45

然后取出3，放入__counter[0]

__counter[0]: 3,52

__counter[1]: NULL

__counter[2]: 1,21,30,45

这时候需要转移

__counter[0]: NULL

__counter[1]: 3,52

__counter[2]: 1,21,30,45

然后取58

__counter[0]: 58

__counter[1]: 3,52

__counter[2]: 1,21,30,45

然后取47

__counter[0]: 47,58

__counter[1]: 3,52

__counter[2]: 1,21,30,45

需要转移

__counter[0]: NULL

__counter[1]: 3,47,52,58

__counter[2]: 1,21,30,45

还需要转移

__counter[0]: NULL

__counter[1]: NULL

__counter[2]: 1,3,21,30,47,45,52,58

还需要转移

__counter[0]: NULL

__counter[1]: NULL

__counter[2]: NULL

__counter[3]: 1,3,21,30,47,45,52,58

然后再取59

__counter[0]: 59

__counter[1]: NULL

__counter[2]: NULL

__counter[3]: 1,3,21,30,47,45,52,58

然后取0

__counter[0]: 0,59

__counter[1]: NULL

__counter[2]: NULL

__counter[3]: 1,3,21,30,47,45,52,58

需要转移

__counter[0]: NULL

__counter[1]: 0,59

__counter[2]: NULL

__counter[3]: 1,3,21,30,47,45,52,58

最后取58

__counter[0]: 58

__counter[1]: 0,59

__counter[2]: NULL

__counter[3]: 1,3,21,30,47,45,52,58

 

 脑算流程总算完了，但代码还是很难理解，先看一个几个相关的函数吧

1.splice:把当前列表的__i位置元素删除，保存在__position里

[cpp]  void list::splice(iterator __position, list&, iterator __i)  

[cpp]  view plain  copy

1. void list::splice(iterator __position, list&, iterator __i)  

 

2.merge:把参数list的元素合并到当前list，参数list的内容会清空的

[c-sharp]  void list<_Tp, _Alloc>::merge(list<_Tp, _Alloc>& __x)

/* Written     By     MaiK */

    STL中的list被实现为环状的双向链表，设置一个“哨兵”node作为end( )。鉴于list的内存分配模型,list不能使用通用的标准sort算法，而是实现自身的sort，但是list有自己的成员函数sort()可供其自身调用,其实际模型是基于合并排序的。普通的mergesort直接将待排序的序列一分为二，然后各自递归调用mergesort，再使用Merge算法用O(n)的时间将已排完序的两个子序列归并，从而总时间效率为n*lg(n)。(mergesort是很好的排序算法，绝对时间很小，n*lg(n)之前的系数也很小，但是在内存中的排序算法中并不常见，我想可能主要还是因为耗空间太多，也是O(n)).

    不过list_sort所使用的mergesort形式上大不一样：将前两个元素归并，再将后两个元素归并，归并这两个小子序列成为4个元素的有序子序列；重复这一过程，得到8个元素的有序子序列，16个的，32个的。。。，直到全部处理完。主要调用了swap和merge函数，而这些又依赖于内部实现的transfer函数(其时间代价为O(1))。该mergesort算法时间代价亦为n*lg(n)，计算起来比较复杂。list_sort中预留了 64个temp_list，所以最多可以处理2^64-1个元素的序列，这应该足够了。

/* Written     By    Lamar */

    类似2进制，每一次进位都是相邻高位数值的一半，所以是类2进制地。例如8，低位4满之后会进4个到8的。