STL学习笔记----4.容器 list

List 使用双向链表来管理元素。

一. List 与 vector或deque的区别

1.List 不支持随机存取。如果你要存取第5个元素，就必须从头开始数。

2.任何位置插入和删除都很快。

3.插入和删除不会造成其它元素pointers， references 和 iterators 失效。

4.List 的迭代器是双向迭代器，所以凡是用到随机存取的迭代器的算法（特别是排序算法）都不能用，只能用list 提供的特殊版本。

 二. Remove() 函数

List 提供了 deque 所有的功能，还增加了 remove() 和 remove_if() 算法

[cpp]  view plain copy

1. //移除所有其值为 val 的元素  
2. c.remove (val)  
3.   
4. //移除所有op为true的元素  
5. c.remove_if (op)  

c.remove() 与 remove() 函数的区别：

[cpp]  view plain copy

1. #include <list>  
2. #include <algorithm>  
3. using namespace std;  
4.   
5.   
6. int main(int argc, char* argv[])  
7. {  
8.     list<int> coll;  
9.       
10.     //6 5 4 3 2 1 1 2 3 4 5 6  
11.     for (int i=1; i<=6; ++i)   
12.     {  
13.         coll.push_front(i);  
14.         coll.push_back(i);  
15.     }  
16.   
17.       
18.     //打印  
19.     cout << "pre:  ";  
20.     copy (coll.begin(), coll.end(),         //source  
21.         ostream_iterator<int> (cout," "));    //destination  
22.     cout << endl;  
23.       
24.     //全局 remove 函数  
25.     //remove (coll.begin(), coll.end(), 3);     //6 5 4 2 1 1 2 4 5 6 5 6  
26.       
27.     //list 版本的 remove 函数  
28.     coll.remove (3);                //6 5 4 2 1 1 2 4 5  
29.   
30.     //打印  
31.     cout << "post: ";  
32.     copy (coll.begin(), coll.end(),         //source  
33.         ostream_iterator<int> (cout," "));    //destination  
34.     cout << endl;  
35.   
36.     return 0;  
37. }  

注意：

全局的 remove() 函数并没有改变容量元素的数量，并且在操作上是后面的元素覆盖了前面的元素。

而 list.remove() 不会出现这种情况。

三. 变动性函数

[cpp]  view plain copy

1. //移除重复元素，只留下一个  
2. c.unique()  
3. c.unique(op)  
4.   
5.   
6. //将 c2 所有元素转移到 c1 内，迭代器 pos 之前  
7. c1.splice(pos, c2)  
8. //将 c2 内 c2pos 所指元素转移到 c1 内，迭代器 pos 之前  
9. c1.splice(pos, c2, c2pos)  
10. //将 c2 内 [c2beg,c2end) 区间内的所有元素转移到 c1 内的迭代器 pos 之前  
11. c1.splice(pos, c2, c2beg, c2end)  
12.   
13.   
14. //按从小到大排序  
15. c.sort()  
16. //按op排序  
17. c.sort(op)  
18.   
19.   
20. //c1 和 c2 容器都是已序的，将 c2 的全部元素转移到 c1，并保证合并后的 list 仍为已序。  
21. c1.merge(c2)  
22. //c1 和 c2 容器都是已序好，将 c2 的全部元素转移到 c1，并保证合并后的 list 在op()原则下仍为已序  
23. c1.merge(c2, op)  
24.   
25.   
26. 将所有元素反序  
27. c.reverse()  

注意：

1. 这些变动性算法，一个容器中元素增加，则另一个容器的元素必须减少。如spice 拼接操作，被拼接的c2容器内元素将不再存在。

2. merge() 操作，要求两个容器是已序的。

四. 实例代码

[cpp]  view plain copy

1. #include <iostream>  
2. #include <list>  
3. #include <algorithm>  
4. using namespace std;  
5.   
6.   
7. void printLists (const list<int>& list1, const list<int>& list2)  
8. {  
9.       
10.     cout << "list1: ";  
11.     copy (list1.begin(), list1.end(), ostream_iterator<int>(cout," "));  
12.     cout << endl << "list2: ";  
13.     copy (list2.begin(), list2.end(), ostream_iterator<int>(cout," "));  
14.     cout << endl << endl;  
15.       
16. }  
17.   
18. int main()  
19. {  
20.     //create two empty lists  
21.     list<int> list1, list2;  
22.       
23.     for (int i=0; i<6; ++i)   
24.     {  
25.         list1.push_back(i);        //0 1 2 3 4 5   
26.         list2.push_front(i);    //5 4 3 2 1 0  
27.     }  
28.     printLists(list1, list2);  
29.       
30.   
31.     //-find() 操作返回元素3的迭代器的位置  
32.     //把list1中的所有元素插入到list2中元素为3之前  
33.     list2.splice( find(list2.begin(),list2.end(), 3), list1 );  
34.     printLists(list1, list2);  
35.       
36.     //相当于倒置  
37.     list2.splice(list2.end(), list2, list2.begin());  
38.     printLists(list1, list2);  
39.       
40.     //排序，并去掉重复  
41.     list2.sort();  
42.     list1 = list2;  
43.     list2.unique();  
44.     printLists(list1, list2);  
45.       
46.     //合并  
47.     list1.merge(list2);  
48.     printLists(list1, list2);  
49.   
50.     return 0;  
51. }