STL源码分析----神奇的 list 的 sort 算法实现
2014-02-19 20:23
399 查看
STL中有一个std::sort算法,但它是不支持std::list的,因为list不提供RandomIterator的支持,但list自己提供了sort算法,把list的元素按从小到大的方式来排序,代码长度到不长,但真是难以读懂,后来扣持了一下午终于搞明白了,贴个总结上来。
list::sort的代码如下(sgi stl):
[cpp] view
plaincopy
template <class _Tp, class _Alloc>
void list<_Tp, _Alloc>::sort()
{
// Do nothing if the list has length 0 or 1.
if (_M_node->_M_next != _M_node && _M_node->_M_next->_M_next != _M_node) {
list<_Tp, _Alloc> __carry;
list<_Tp, _Alloc> __counter[64];
int __fill = 0;
while (!empty()) {
__carry.splice(__carry.begin(), *this, begin());
int __i = 0;
while(__i < __fill && !__counter[__i].empty()) {
__counter[__i].merge(__carry);
__carry.swap(__counter[__i++]);
}
__carry.swap(__counter[__i]);
if (__i == __fill) ++__fill;
}
for (int __i = 1; __i < __fill; ++__i)
__counter[__i].merge(__counter[__i-1]);
swap(__counter[__fill-1]);
}
}
行数的确不多,但还真麻烦,我先说一下他是怎么实现的,但具体为什么这么做,我不知道。
比如我们的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(i+1)次方时,就要把__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
plaincopy
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的。
list::sort的代码如下(sgi stl):
[cpp] view
plaincopy
template <class _Tp, class _Alloc>
void list<_Tp, _Alloc>::sort()
{
// Do nothing if the list has length 0 or 1.
if (_M_node->_M_next != _M_node && _M_node->_M_next->_M_next != _M_node) {
list<_Tp, _Alloc> __carry;
list<_Tp, _Alloc> __counter[64];
int __fill = 0;
while (!empty()) {
__carry.splice(__carry.begin(), *this, begin());
int __i = 0;
while(__i < __fill && !__counter[__i].empty()) {
__counter[__i].merge(__carry);
__carry.swap(__counter[__i++]);
}
__carry.swap(__counter[__i]);
if (__i == __fill) ++__fill;
}
for (int __i = 1; __i < __fill; ++__i)
__counter[__i].merge(__counter[__i-1]);
swap(__counter[__fill-1]);
}
}
行数的确不多,但还真麻烦,我先说一下他是怎么实现的,但具体为什么这么做,我不知道。
比如我们的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(i+1)次方时,就要把__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
plaincopy
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的。
相关文章推荐
- STL源码分析----神奇的 list 的 sort 算法实现
- STL源码分析----神奇的 list 的 sort 算法实现
- STL 源码分析《1》---- list 归并排序的 迭代版本, 神奇的 STL list sort
- STL 源码分析《1》---- list 归并排序的 迭代版本, 神奇的 STL list sort
- stl里sort源码算法分析
- stl中list的sort算法实现
- <stl>list::sort源码分析
- STL源码——list sort:归并排序的非递归实现
- C++ STL list 成员函数 sort算法分析
- STL中list的sort算法的实现原理
- STL源码系列--List::sort算法解析
- stl中list的sort算法实现
- Android版数据结构与算法(三):基于链表的实现LinkedList源码彻底分析
- 【LeetCode-面试算法经典-Java实现】【147-Insertion Sort List(链表插入排序)】
- LinkedList的实现源码分析
- SGI STL: list::sort()算法
- 从零开始学C++之STL(七):剩下5种算法代码分析与使用示例(remove 、rotate 、sort、lower_bound、accumulate)
- STL源码之copy算法分析
- 集合框架源码分析三(实现类篇ArrayList,LinkedList,HashMap)
- 链表的归并排序:来自STL_ list_ sort 算法