STL容器总结之list

  STL容器总结之list

   在使用std::list<>链表时，难免会对数据进行添加删除操作。而遍历链表则有两种方式：通过索引访问，象数组一样处理；通过std::list<>::iterator链表遍历器进行访问

STL 中的list 就是一 双向链表，可高效地进行插入删除元素。

list不支持随机访问。所以没有 at(pos)和operator[]。

list 对象list1, list2 分别有元素list1(1,2,3),list2(4,5,6) 。list< int>::iterator it;

1.构造，析构

[cpp] view plain copy

1. list<Elem> c //创建一个空的list  
2.   
3. list<Elem> c1(c2) //复制另一个同类型元素的list  
4.   
5. list<Elem>c(n) //创建n个元素的list，每个元素值由默认构造函数确定  
6.   
7. list<Elem>c(n,elem) //创建n个元素的list，每个元素的值为elem  
8.   
9. list<Elem>c(begin,end) //由迭代器创建list,迭代区间为[begin,end)  
10.   
11. c.~list();             // 销毁所有元素,释放内存  

2.其他

[cpp] view plain copy

1. c.size() //返回容器的元素个数  
2.   
3. c.swap(c2) //将c2和c的元素互换  
4.   
5. c.empty() //判断容器是否为空  
6.   
7. c.max_size() //返回容器中最大数据的数量  
8.   
9. c.resize(num) //重新指定链表的长度  
10.   
11. c.reverse() //反转链表  
12.   
13. c.sort() //对列表进行排序，默认升序，可以自定义回调函数  
14. //示例  
15. list 对象L1(4,3,5,1,4)  
16. L1.sort( );                 // L1(1,3,4,4,5)  
17. L1.sort( greater <int >() ); // L1(5,4,4,3,1)  
18.   
19. c.merge() //合并两个有序列表使之有序  
20. //示例  
21. // 升序  
22. list1.merge(list2);          // list1(1,2,3,4,5,6) list2 现为空  
23. // 降序  
24. L1( 3,2,1), L2(6,5,4)  
25. L1.merge(L2, greater <int >() ); // list1(6,5,4,3,2,1) list2 现为空  
26.   
27. c.splice() //对两个链表进行结合( 三个重载函数) 结合后第二个链表清空  
28. //示例  
29. list1.splice( ++list1.begin(),list2);  
30. // list1(1,4,5,6,2,3) list2 为空  
31.   list1.splice( ++list1.begin(),list2,list2.begin());  
32. // list1( 1,4,2,3); list2(5,6)  
33. list1.splice( ++list1.begin(),list2,++list2.begin(),list2.end());  
34. //list1( 1, 5,6, 2,3); list2(4)  

3.赋值

[cpp] view plain copy

1. c.assign(begin,end) //将[begin,end)区间中的数据赋值给c  
2.   
3. c.assign(n,Elem) //将n个Elem的拷贝赋值给c  
4.   
5. c.swap(c2) //将c2和c的元素互换  

4.数据访问

[cpp] view plain copy

1. c.front() //返回第一个数据  
2.   
3. c.back() //返回最后一个数据  
4.   
5. c.begin() //返回指向第一个元素的迭代器(指针)  
6.   
7. c.end() //返回指向最后一个数据的下一个位置的迭代器(指针)  
8.   
9. c.rbegin() //返回逆向队列的第一个数据,也就是返回容器中倒数第一个元素的迭代器  
10.   
11. c.rend() //返回指向逆向队列的最后一个数据的下一个位置的迭代器，  
12. //也就是返回容器中倒数最后一个元素之后的迭代器  

5.插入数据

[cpp] view plain copy

1. c.push_back(Elem) //list元素尾部增加一个元素x  
2.   
3. c.push_front(Elem) //list元素首元素钱添加一个元素X  
4.   
5. c.insert(pos,Elem) //在pos位置插入一个Elem拷贝，返回新数据的位置  
6.   
7. c.insert(pos,n,Elem) //在pos位置插入n个Elem数据，无返回值  
8.   
9. c.insert(pos,begin,end) //在pos位置插入在[begin,end)区间的数据，无返回值  

6.删除数据

[cpp] view plain copy

1. c.pop_back() //删除容器尾元素，当且仅当容器不为空    
2.     
3. c.pop_front() //删除容器首元素，当且仅当容器不为空    
4.     
5. c.remove(Elem) //删除容器中所有元素值等于x的元素   
6.   
7. /**  
8.  remove_if()删除条件满足的元素(会遍历一次链表)  
9. */    
10. void remove_if_test(){    
11. ShowList(g_list1);    
12. g_list1.remove_if(myFun);    
13. ShowList(g_list1);    
14. }    
15.     
16. c.clear() //删除容器中的所有元素    
17.     
18. c.erase(pos) //删除pos位置的数据，返回下一个数据的位置    
19.     
20. c.erase(begin,end) //删除[begin,end)区间的数据，返回下一个数据的位置    
21.     
22. c.unique() //删除相邻重复元素    
23. //示例    
24. L1( 1, 1 ,4,3,5,1)    
25. L1.unique( );         // L1(1,4,3,5,1)    

7.示例

[cpp] view plain copy

1. #include<iostream>  
2. #include<stdio.h>  
3. #include<list>  
4. using namespace std;  
5. list < int > g_list1;  
6. list < int > g_list2;  
7. /** 
8.   初始化全局列表 
9. */  
10. void InitList(){  
11. // push_back()增加一元素到链表尾  
12. g_list1.push_back( 1 );  
13. g_list1.push_back( 2 );  
14. g_list1.push_back( 3 );  
15. // push_front()增加一元素到链表头  
16. g_list2.push_front( 6 );  
17. g_list2.push_front( 5 );  
18. g_list2.push_front( 4 );  
19. }  
20. /** 
21.   输出一个链表 
22. */  
23. void ShowList(list < int >& listTemp){  
24. // size()返回链表中元素个数  
25. cout << listTemp.size() << endl;  
26.   
27. for (list < int > ::iterator it = listTemp.begin(); it != listTemp.end(); ++ it){  
28.     cout << * it << ' ' ;  
29. }  
30.    cout << endl;  
31. }  
32. /** 
33.   构造函数，空链表 
34. */  
35. void constructor_test0(){  
36. list < int > listTemp;  
37. cout << listTemp.size() << endl;  
38. }  
39. /** 
40.  构造函数，建一个含三个默认值是0的元素的链表 
41. */  
42. void constructor_test1(){  
43.   list < int > listTemp( 3 );  
44.   ShowList(listTemp);  
45. }  
46. /** 
47.   构造函数，建一个含五个元素的链表，值都是1 
48. */  
49. void constructor_test2(){  
50.   list < int > listTemp( 5 , 1 );  
51.   ShowList(listTemp);  
52. }  
53. /** 
54.   构造函数，建一个g_list1的copy链表 
55. */  
56. void constructor_test3(){  
57.  list < int > listTemp(g_list1);  
58.  ShowList(listTemp);  
59. }  
60. /** 
61.   构造函数，listTemp含g_list1一个区域的元素[_First, _Last) 
62. */  
63. void constructor_test4(){  
64.  list < int > listTemp(g_list1.begin(), g_list1.end());  
65.  ShowList(listTemp);  
66. }  
67. /** 
68.  assign()分配值，有两个重载 
69.  template <class InputIterator> 
70.  void assign ( InputIterator first, InputIterator last ); 
71.  void assign ( size_type n, const T& u ); 
72. */  
73. void assign_test(){  
74.   list < int > listTemp( 5 , 1 );  
75.   ShowList(listTemp);  
76.   listTemp.assign( 4 , 3 );  
77.   ShowList(listTemp);  
78.   
79.   listTemp.assign( ++ g_list1.begin(), g_list1.end());  
80.   ShowList(listTemp);  
81. }  
82. /** 
83.  operator= 
84. */  
85. void operator_equality_test(){  
86.  g_list1 = g_list2;  
87.  ShowList(g_list1);  
88.  ShowList(g_list2);  
89. }  
90. /** 
91.   front()返回第一个元素的引用 
92. */  
93. void front_test7(){  
94.   cout << g_list1.front() << endl;  
95. }  
96. /** 
97.   back()返回最后一元素的引用 
98. */  
99. void back_test(){  
100.  cout << g_list1.back() << endl;  
101. }  
102. /** 
103.   begin()返回第一个元素的指针(iterator) 
104. */  
105. void begin_test(){  
106.  list < int > ::iterator it1 = g_list1.begin();  
107.  cout << *++ it1 << endl;  
108.   
109.  list < int > ::const_iterator it2 = g_list1.begin();  
110.  it2 ++ ;  
111.  // (*it2)++; // *it2 为const 不用修改  
112.  cout << * it2 << endl;  
113.   
114. }  
115. /** 
116.   end()返回 [最后一个元素的下一位置的指针] (list为空时end()= begin()) 
117. */  
118. void end_test(){  
119. list < int > ::iterator it = g_list1.end(); // 注意是：最后一个元素的下一位置的指针  
120. -- it;  
121. cout << * it << endl;  
122. }  
123. /** 
124.   rbegin()返回链表最后一元素的后向指针 
125. */  
126. void rbegin_test(){  
127.  list < int > ::reverse_iterator it = g_list1.rbegin();  
128.  for (; it != g_list1.rend(); ++ it){  
129.  cout << * it << ' ' ;  
130. }  
131.  cout << endl;  
132. }  
133. /** 
134.   rend()返回链表第一元素的下一位置的后向指针 
135. */  
136. void rend_test(){  
137. list < int > ::reverse_iterator it = g_list1.rend();  
138. -- it;  
139. cout << * it << endl;  
140. }  
141. /** 
142.   push_back()增加一元素到链表尾 
143. */  
144. void push_back_test(){  
145. ShowList(g_list1);  
146. g_list1.push_back( 4 );  
147. ShowList(g_list1);  
148. }  
149. /** 
150.   push_front()增加一元素到链表头 
151. */  
152. void push_front_test(){  
153. ShowList(g_list1);  
154. g_list1.push_front( 4 );  
155. ShowList(g_list1);  
156. }  
157. /** 
158.   pop_back()删除链表尾的一个元素 
159. */  
160. void pop_back_test(){  
161. ShowList(g_list1);  
162. cout << endl;  
163.   
164. g_list1.pop_back();  
165. ShowList(g_list1);  
166.   
167. }  
168. /** 
169.  pop_front()删除链表头的一元素 
170. */  
171. void pop_front_test(){  
172. ShowList(g_list1);  
173. cout << endl;  
174.   
175. g_list1.pop_front();  
176. ShowList(g_list1);  
177. }  
178. /** 
179.  clear()删除所有元素 
180. */  
181. void clear_test(){  
182. ShowList(g_list1);  
183. g_list1.clear();  
184. ShowList(g_list1);  
185. }  
186. /** 
187.   erase()删除一个元素或一个区域的元素(两个重载函数) 
188. */  
189. void erase_test()  
190. {  
191. ShowList(g_list1);  
192. g_list1.erase(g_list1.begin());  
193. ShowList(g_list1);  
194.   
195. cout << endl;  
196.   
197. ShowList(g_list2);  
198. g_list2.erase( ++ g_list2.begin(), g_list2.end());  
199. ShowList(g_list2);  
200. }  
201. /** 
202.   remove()删除链表中匹配值的元素(匹配元素全部删除) 
203. */  
204. void remove_test(){  
205. ShowList(g_list1);  
206. g_list1.push_back( 1 );  
207. ShowList(g_list1);  
208.   
209. g_list1.remove( 1 );  
210. ShowList(g_list1);  
211. }  
212.   
213. bool myFun( const int & value) { return (value < 2 ); }  
214. /** 
215.  remove_if()删除条件满足的元素(会遍历一次链表) 
216. */  
217. void remove_if_test(){  
218. ShowList(g_list1);  
219. g_list1.remove_if(myFun);  
220. ShowList(g_list1);  
221. }  
222. /** 
223.   empty()判断是否链表为空 
224. */  
225. void empty_test()  
226. {  
227. list < int > listTemp;  
228. if (listTemp.empty())  
229. cout << " listTemp为空 " << endl;  
230. else  
231. cout << " listTemp不为空 " << endl;  
232. }  
233. /** 
234.  max_size()返回链表最大可能长度:1073741823 
235. */  
236. void max_size_test(){  
237. list < int > ::size_type nMax = g_list1.max_size();  
238. cout << nMax << endl;  
239. }  
240. /** 
241. resize()重新定义链表长度(两重载函数)： 
242. */  
243. void resize_test(){  
244. ShowList(g_list1);  
245. g_list1.resize( 9 ); // 用默认值填补  
246. ShowList(g_list1);  
247. cout << endl;  
248.   
249. ShowList(g_list2);  
250. g_list2.resize( 9 , 51 ); // 用指定值填补  
251. ShowList(g_list2);  
252. }  
253. /** 
254. reverse()反转链表 
255. */  
256. void reverse_test(){  
257. ShowList(g_list1);  
258. g_list1.reverse();  
259. ShowList(g_list1);  
260. }  
261. /** 
262.   sort()对链表排序，默认升序(两个重载函数) 
263. */  
264. void sort_test(){  
265. list < int > listTemp;  
266. listTemp.push_back( 9 );  
267. listTemp.push_back( 3 );  
268. listTemp.push_back( 5 );  
269. listTemp.push_back( 1 );  
270. listTemp.push_back( 4 );  
271. listTemp.push_back( 3 );  
272.   
273. ShowList(listTemp);  
274. listTemp.sort();  
275. ShowList(listTemp);  
276.   
277. listTemp.sort(greater < int > ());  
278. ShowList(listTemp);  
279. }  
280. /** 
281.   merge()合并两个升序序链表并使之成为另一个升序. 
282. */  
283. void merge_test1(){  
284. list < int > listTemp2;  
285. listTemp2.push_back( 3 );  
286. listTemp2.push_back( 4 );  
287.   
288. list < int > listTemp3;  
289. listTemp3.push_back( 9 );  
290. listTemp3.push_back( 10 );  
291.   
292. ShowList(listTemp2);  
293. cout << endl;  
294. ShowList(listTemp3);  
295. cout << endl;  
296.   
297. listTemp2.merge(listTemp3);  
298. ShowList(listTemp2);  
299. }  
300.   
301. bool myCmp ( int first, int second)  
302. { return ( int (first) > int (second) ); }  
303. /** 
304.   merge()合并两个降序链表并使之成为另一个降序. 
305. */  
306. void merge_test2(){  
307. list < int > listTemp2;  
308. listTemp2.push_back( 4 );  
309. listTemp2.push_back( 3 );  
310.   
311. list < int > listTemp3;  
312. listTemp3.push_back( 10 );  
313. listTemp3.push_back( 9 );  
314.   
315. ShowList(listTemp2);  
316. cout << endl;  
317. ShowList(listTemp3);  
318. cout << endl;  
319.   
320. // listTemp2.merge(listTemp3, greater<int>()); // 第二个参数可以是自己定义的函数如下  
321. listTemp2.merge(listTemp3, myCmp);  
322. ShowList(listTemp2);  
323. }  
324. /** 
325.    splice()对两个链表进行结合(三个重载函数),结合后第二个链表清空 
326.    void splice ( iterator position, list<T,Allocator>& x ); 
327.    void splice ( iterator position, list<T,Allocator>& x, iterator i ); 
328.    void splice ( iterator position, list<T,Allocator>& x, iterator first, iterator last ); 
329. */  
330. void splice_test(){  
331. list < int > listTemp1(g_list1);  
332. list < int > listTemp2(g_list2);  
333.   
334. ShowList(listTemp1);  
335. ShowList(listTemp2);  
336. cout << endl;  
337.   
338. //  
339. listTemp1.splice( ++ listTemp1.begin(), listTemp2);  
340. ShowList(listTemp1);  
341. ShowList(listTemp2);  
342.   
343. //  
344. listTemp1.assign(g_list1.begin(), g_list1.end());  
345. listTemp2.assign(g_list2.begin(), g_list2.end());  
346. listTemp1.splice( ++ listTemp1.begin(), listTemp2, ++ listTemp2.begin());  
347. ShowList(listTemp1);  
348. ShowList(listTemp2);  
349.   
350. //  
351. listTemp1.assign(g_list1.begin(), g_list1.end());  
352. listTemp2.assign(g_list2.begin(), g_list2.end());  
353. listTemp1.splice( ++ listTemp1.begin(), listTemp2, ++ listTemp2.begin(), listTemp2.end());  
354. ShowList(listTemp1);  
355. ShowList(listTemp2);  
356.   
357. }  
358. /** 
359.    insert()在指定位置插入一个或多个元素(三个重载函数) 
360.    iterator insert ( iterator position, const T& x ); 
361.    void insert ( iterator position, size_type n, const T& x ); 
362.    template <class InputIterator> 
363.    void insert ( iterator position, InputIterator first, InputIterator last ); 
364. */  
365. void insert_test(){  
366. list < int > listTemp1(g_list1);  
367. ShowList(listTemp1);  
368. listTemp1.insert(listTemp1.begin(), 51 );  
369. ShowList(listTemp1);  
370. cout << endl;  
371.   
372. list < int > listTemp2(g_list1);  
373. ShowList(listTemp2);  
374. listTemp2.insert(listTemp2.begin(), 9 , 51 );  
375. ShowList(listTemp2);  
376. cout << endl;  
377.   
378. list < int > listTemp3(g_list1);  
379. ShowList(listTemp3);  
380. listTemp3.insert(listTemp3.begin(), g_list2.begin(), g_list2.end());  
381. ShowList(listTemp3);  
382.   
383. }  
384. /** 
385.  swap()交换两个链表(两个重载) 
386. */  
387. void swap_test(){  
388. ShowList(g_list1);  
389. ShowList(g_list2);  
390. cout << endl;  
391.   
392. g_list1.swap(g_list2);  
393. ShowList(g_list1);  
394. ShowList(g_list2);  
395. }  
396.   
397. bool same_integral_part ( double first, double second)  
398. { return ( int (first) == int (second) ); }  
399. /** 
400.  unique()删除相邻重复元素 
401. */  
402. void unique_test(){  
403. list < int > listTemp;  
404. listTemp.push_back( 1 );  
405. listTemp.push_back( 1 );  
406. listTemp.push_back( 4 );  
407. listTemp.push_back( 3 );  
408. listTemp.push_back( 5 );  
409. listTemp.push_back( 1 );  
410. list < int > listTemp2(listTemp);  
411.   
412. ShowList(listTemp);  
413. listTemp.unique(); // 不会删除不相邻的相同元素  
414. ShowList(listTemp);  
415. cout << endl;  
416.   
417. listTemp.sort();  
418. ShowList(listTemp);  
419. listTemp.unique();  
420. ShowList(listTemp);  
421. cout << endl;  
422.   
423. listTemp2.sort();  
424. ShowList(listTemp2);  
425. listTemp2.unique(same_integral_part);  
426. ShowList(listTemp2);  
427.   
428. }  
429. /** 
430.   主函数，列表测试 
431. */  
432. int main(){  
433. InitList();  
434.  ShowList(g_list1);  
435.  ShowList(g_list2);  
436.   
437.  constructor_test0();  
438.  constructor_test1();  
439.  constructor_test2();  
440.  constructor_test3();  
441.  constructor_test4();  
442.  assign_test();  
443.  operator_equality_test();  
444.  front_test7();  
445.  back_test();  
446.  begin_test();  
447.  end_test();  
448.  rbegin_test();  
449.  rend_test();  
450.  push_back_test();  
451.  push_front_test();  
452.  pop_back_test();  
453.  pop_front_test();  
454.  clear_test();  
455.  erase_test();  
456.  remove_test();  
457.  remove_if_test();  
458.  empty_test();  
459.  max_size_test();  
460.  resize_test();  
461.  reverse_test();  
462.  sort_test();  
463.  merge_test1();  
464.  merge_test2();  
465.  splice_test();  
466.  insert_test();  
467.  swap_test();  
468.  unique_test();  
469. return 0 ;  
470. }  

参考博客： http://blog.csdn.net/lanyzh0909/article/details/7567696