【STL】list基础

各个容器有很多的相似性。先学好一个，其它的就好办了。先从基础开始。

先看看他们的分类吧

• 标准STL序列容器：vector、string、deque和list。
• 标准STL关联容器：set、multiset、map和multimap。
• 非标准序列容器slist和rope。slist是一个单向链表，rope本质上是一个重型字符串。
• 非标准关联容器hash_set、hash_multiset、hash_map和hash_multimap。

  （各容器成员对比见：【STL】各容器成员对比表）

先看看list。

list

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

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

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

list成员	说明
constructor	构造函数
destructor	析构函数
operator=	赋值重载运算符
assign	分配值
front	返回第一个元素的引用
back	返回最后一元素的引用
begin	返回第一个元素的指针(iterator)
end	返回最后一个元素的下一位置的指针
rbegin	返回链表最后一元素的后向指针(reverse_iterator or const)
rend	返回链表第一元素的下一位置的后向指针
push_back	增加一元素到链表尾
push_front	增加一元素到链表头
pop_back	pop_back()删除链表尾的一个元素
pop_front	删除链表头的一元素
clear	删除所有元素
erase	删除一个元素或一个区域的元素(两个重载)
remove	删除链表中匹配值的元素(匹配元素全部删除)
remove_if	删除条件满足的元素(遍历一次链表)，参数为自定义的回调函数
empty	判断是否链表为空
max_size	返回链表最大可能长度
size	返回链表中元素个数
resize	重新定义链表长度(两重载函数)
reverse	反转链表
sort	对链表排序，默认升序
merge	合并两个有序链表并使之有序
splice	对两个链表进行结合(三个重载函数) 结合后第二个链表清空
insert	在指定位置插入一个或多个元素(三个重载函数)
swap	交换两个链表(两个重载)
unique	删除相邻重复元素

1.list构造函数 

1 list<int> L0;       // 空链表

2 

3 list<int> L1(9);   // 建一个含个默认值是的元素的链表

4 

5 list<int> L2(5,1); // 建一个含个元素的链表，值都是

6 

7 list<int> L3(L2);  // 建一个L2的copy链表

8 

9 list<int> L4(L0.begin(), L0.end());//建一个含L0一个区域的元素

2. assign()分配值，有两个重载

L1.assign(4,3);                                // L1(3,3,3,3)

L1.assign(++list1.beging(), list2.end());   // L1(2,3) 

3．operator= 赋值重载运算符

L1 = list1;   // L1(1,2,3) 

4.   front()返回第一个元素的引用

int nRet = list1.front()    // nRet = 1 

5.  back()返回最后一元素的引用

int nRet = list1.back()     // nRet = 3 

6.  begin()返回第一个元素的指针(iterator)

it = list1.begin();    // *it = 1 

7.   end()返回最后一个元素的下一位置的指针(list为空时end()=begin())

it = list1.end();

--it;                       // *it = 3 

8.rbegin()返回链表最后一元素的后向指针(reverse_iterator or const)

list<int>::reverse_iterator it = list1.rbegin();  // *it = 3 

9.   rend()返回链表第一元素的下一位置的后向指针

list<int>::reverse_iterator it = list1.rend(); // *(--riter) = 1 

10.push_back()增加一元素到链表尾

list1.push_back(4)       // list1(1,2,3,4) 

11. push_front()增加一元素到链表头

list1.push_front(4)      // list1(4,1,2,3) 

12. pop_back()删除链表尾的一个元素

list1.pop_back()          // list1(1,2) 

13.pop_front()删除链表头的一元素

list1.pop_front()　         // list1(2,3) 

14．clear()删除所有元素

list1.clear();   // list1空了,list1.size() =０ 

15.erase()删除一个元素或一个区域的元素(两个重载函数)

list1.erase(list1.begin());                // list1(2,3)

list1.erase(++list1.begin(),list1.end()); // list1(1) 

16.    remove()删除链表中匹配值的元素(匹配元素全部删除)

list对象L1(4,3,5,1,4)

L1.remove(4);               // L1(3,5,1); 

17.remove_if()删除条件满足的元素(遍历一次链表)，参数为自定义的回调函数

// 小于2的值删除

bool myFun(const int& value) { return (value < 2); }

list1.remove_if(myFun);    // list1(3)　 

18.empty()判断是否链表为空

bool bRet = L1.empty(); //若L1为空，bRet = true，否则bRet = false。 

19.max_size()返回链表最大可能长度

list<int>::size_type nMax = list1.max_size();// nMax = 1073741823 

20．size()返回链表中元素个数

list<int>::size_type nRet = list1.size();      // nRet = 3 

21.resize()重新定义链表长度(两重载函数)

list1.resize(5)    // list1 (1,2,3,0,0)用默认值填补

list1.resize(5,4)    // list1 (1,2,3,4,4)用指定值填补 

22.reverse()反转链表:

list1.reverse();     // list1(3,2,1) 

23.sort()对链表排序，默认升序(可自定义回调函数)

list对象L1(4,3,5,1,4) 

L1.sort();                 // L1(1,3,4,4,5)

L1.sort(greater<int>()); // L1(5,4,4,3,1) 

24.merge()合并两个有序链表并使之有序

// 升序

list1.merge(list2);          // list1(1,2,3,4,5,6) list2现为空

// 降序

L1(3,2,1), L2(6,5,4)

L1.merge(L2, greater<int>()); // list1(6,5,4,3,2,1) list2现为空 

25.splice()对两个链表进行结合(三个重载函数) 结合后第二个链表清空

list1.splice(++list1.begin(),list2); 

// list1(1,4,5,6,2,3) list2为空

 list1.splice(++list1.begin(),list2,list2.begin());

// list1(1,4,2,3); list2(5,6)

list1.splice(++list1.begin(),list2,++list2.begin(),list2.end());

//list1(1,5,6,2,3); list2(4) 

26.insert()在指定位置插入一个或多个元素(三个重载函数)

list1.insert(++list1.begin(),9);  // list1(1,9,2,3)

list1.insert(list1.begin(),2,9);  // list1(9,9,1,2,3);

list1.insert(list1.begin(),list2.begin(),--list2.end());//list1(4,5,1,2,3); 

27.swap()交换两个链表(两个重载)

list1.swap(list2);   // list1（4，5，6） list2（1，2，3） 

28. unique()删除相邻重复元素

L1(1,1,4,3,5,1)

L1.unique();         // L1(1,4,3,5,1)

1 bool same_integral_part (double first, double second)

2 { return ( int(first)==int(second) ); }

L1.unique(same_integral_part);

例子：

  1 // ------------------------------------------------------------------------- 

  2 //    文件名        :     list1.cpp

  3 //    功能描述    :    STL中的list就是一双向链表，可高效地进行插入删除元素。

  4 //                

  5 // -------------------------------------------------------------------------

  6 #include "stdafx.h"

  7 #include <iostream>

  8 #include <list>

  9 using namespace std;

 10 

 11 list<int> g_list1;

 12 list<int> g_list2;

 13 

 14 //////////////////////////////////////////////////////////////////////////

 15 

 16 // 初始化全局链表

 17 void InitList()

 18 {

 19     //  push_back()增加一元素到链表尾

 20     g_list1.push_back(1);

 21     g_list1.push_back(2);

 22     g_list1.push_back(3);

 23 

 24     // push_front()增加一元素到链表头

 25     g_list2.push_front(6);

 26     g_list2.push_front(5);

 27     g_list2.push_front(4);

 28 }

 29 

 30 // 输出一个链表

 31 void ShowList(list<int>& listTemp)

 32 {

 33     //  size()返回链表中元素个数

 34     cout << listTemp.size() << endl;

 35 

 36     for (list<int>::iterator it = listTemp.begin(); it != listTemp.end(); ++it)

 37     {

 38         cout << *it << ' ';

 39     }

 40     cout << endl;

 41 }

 42 

 43 //////////////////////////////////////////////////////////////////////////

 44 

 45 // 构造函数，空链表

 46 void constructor_test0()

 47 {

 48     list<int> listTemp;

 49     cout << listTemp.size() << endl;

 50 }

 51 

 52 // 构造函数，建一个含三个默认值是0的元素的链表

 53 void constructor_test1()

 54 {

 55     list<int> listTemp(3);

 56     ShowList(listTemp);

 57 }

 58 

 59 // 构造函数，建一个含五个元素的链表，值都是1

 60 void constructor_test2()

 61 {

 62     list<int> listTemp(5, 1);

 63     ShowList(listTemp);

 64 }

 65 

 66 // 构造函数，建一个g_list1的copy链表

 67 void constructor_test3()

 68 {

 69     list<int> listTemp(g_list1);

 70     ShowList(listTemp);

 71 }

 72 

 73 // 构造函数，listTemp含g_list1一个区域的元素[_First, _Last)

 74 void constructor_test4()

 75 {

 76     list<int> listTemp(g_list1.begin(), g_list1.end());

 77     ShowList(listTemp);

 78 }

 79 

 80 // assign()分配值，有两个重载

 81 // template <class InputIterator>

 82 // void assign ( InputIterator first, InputIterator last );

 83 // void assign ( size_type n, const T& u );

 84 void assign_test()

 85 {

 86     list<int> listTemp(5, 1);

 87     ShowList(listTemp);

 88 

 89     listTemp.assign(4, 3);

 90     ShowList(listTemp);

 91 

 92     listTemp.assign(++g_list1.begin(), g_list1.end());

 93     ShowList(listTemp);

 94 }

 95 

 96 // operator=

 97 void operator_equality_test()

 98 {

 99     g_list1 = g_list2;

100     ShowList(g_list1);

101     ShowList(g_list2);

102 }

103 

104 // front()返回第一个元素的引用

105 void front_test7()

106 {

107     cout << g_list1.front() << endl;

108 }

109 

110 // back()返回最后一元素的引用

111 void back_test()

112 {

113     cout << g_list1.back() << endl;

114 }

115 

116 // begin()返回第一个元素的指针(iterator)

117 void begin_test()

118 {

119     list<int>::iterator it1 = g_list1.begin();

120     cout << *++it1 << endl;

121 

122     list<int>::const_iterator it2 = g_list1.begin();

123     it2++;

124     // (*it2)++;    //     *it2 为const 不用修改

125     cout << *it2 << endl;    

126 

127 }

128 

129 // end()返回 [最后一个元素的下一位置的指针] (list为空时end()= begin())

130 void end_test()

131 {

132     list<int>::iterator it  = g_list1.end();    // 注意是：最后一个元素的下一位置的指针

133     --it;

134     cout << *it << endl;

135 }

136 

137 //  rbegin()返回链表最后一元素的后向指针

138 void rbegin_test()

139 {

140     list<int>::reverse_iterator it = g_list1.rbegin();

141     for (; it != g_list1.rend(); ++it)

142     {

143         cout << *it << ' ';

144     }

145     cout << endl;

146 }

147 

148 //  rend()返回链表第一元素的下一位置的后向指针

149 void rend_test()

150 {

151     list<int>::reverse_iterator it = g_list1.rend();

152     --it;

153     cout << *it << endl;

154 }

155 

156 // push_back()增加一元素到链表尾

157 void push_back_test()

158 {

159     ShowList(g_list1);

160     g_list1.push_back(4);

161     ShowList(g_list1);

162 }

163 

164 // push_front()增加一元素到链表头 

165 void push_front_test()

166 {

167     ShowList(g_list1);

168     g_list1.push_front(4);

169     ShowList(g_list1);

170 }

171 

172 // pop_back()删除链表尾的一个元素

173 void pop_back_test()

174 {

175     ShowList(g_list1);

176     cout << endl;

177 

178     g_list1.pop_back();

179     ShowList(g_list1);

180 

181 }

182 

183 // pop_front()删除链表头的一元素

184 void pop_front_test()

185 {

186     ShowList(g_list1);

187     cout << endl;

188 

189     g_list1.pop_front();

190     ShowList(g_list1);

191 }

192 

193 // clear()删除所有元素

194 void clear_test()

195 {

196     ShowList(g_list1);

197     g_list1.clear();

198     ShowList(g_list1);

199 }

200 

201 // erase()删除一个元素或一个区域的元素(两个重载函数)

202 void erase_test()

203 {

204     ShowList(g_list1);

205     g_list1.erase(g_list1.begin());

206     ShowList(g_list1);

207 

208     cout << endl;

209 

210     ShowList(g_list2);

211     g_list2.erase(++g_list2.begin(), g_list2.end());

212     ShowList(g_list2);

213 }

214 

215 // remove()删除链表中匹配值的元素(匹配元素全部删除)

216 void remove_test()

217 {

218     ShowList(g_list1);

219     g_list1.push_back(1);

220     ShowList(g_list1);

221 

222     g_list1.remove(1);

223     ShowList(g_list1);

224 }

225 

226 bool myFun(const int& value) { return (value < 2); }

227 // remove_if()删除条件满足的元素(会遍历一次链表)

228 void remove_if_test()

229 {

230     ShowList(g_list1);

231     g_list1.remove_if(myFun);

232     ShowList(g_list1);

233 }

234 

235 

236 // empty()判断是否链表为空

237 void empty_test()

238 {

239     list<int> listTemp;

240     if (listTemp.empty())

241         cout << "listTemp为空" << endl;

242     else

243         cout << "listTemp不为空" << endl;

244 }

245 

246 

247 //  max_size()返回链表最大可能长度:1073741823

248 void max_size_test()

249 {

250     list<int>::size_type nMax = g_list1.max_size();

251     cout << nMax << endl;

252 }

253 

254 

255 // resize()重新定义链表长度(两重载函数)：

256 void resize_test()

257 {

258     ShowList(g_list1);

259     g_list1.resize(9);        // 用默认值填补

260     ShowList(g_list1);

261     cout << endl;

262 

263     ShowList(g_list2);

264     g_list2.resize(9, 51);    // 用指定值填补

265     ShowList(g_list2);

266 }

267 

268 // reverse()反转链表

269 void reverse_test()

270 {

271     ShowList(g_list1);

272     g_list1.reverse();

273     ShowList(g_list1);

274 }

275 

276 

277 // sort()对链表排序，默认升序(两个重载函数)

278 void sort_test()

279 {

280     list<int> listTemp;

281     listTemp.push_back(9);

282     listTemp.push_back(3);

283     listTemp.push_back(5);

284     listTemp.push_back(1);

285     listTemp.push_back(4);

286     listTemp.push_back(3);

287 

288     ShowList(listTemp);

289     listTemp.sort();

290     ShowList(listTemp);

291 

292     listTemp.sort(greater<int>());

293     ShowList(listTemp);

294 }

295 

296 // merge()合并两个升序序链表并使之成为另一个升序.

297 void merge_test1()

298 {

299     list<int> listTemp2;

300     listTemp2.push_back(3);

301     listTemp2.push_back(4);

302 

303     list<int> listTemp3;

304     listTemp3.push_back(9);

305     listTemp3.push_back(10);

306 

307     ShowList(listTemp2);

308     cout << endl;

309     ShowList(listTemp3);

310     cout << endl;

311 

312     listTemp2.merge(listTemp3);

313     ShowList(listTemp2);

314 }

315 

316 

317 bool myCmp (int first, int second)

318 { return ( int(first)>int(second) ); }

319 

320 // merge()合并两个降序链表并使之成为另一个降序.

321 void merge_test2()

322 {

323     list<int> listTemp2;

324     listTemp2.push_back(4);

325     listTemp2.push_back(3);

326 

327     list<int> listTemp3;

328     listTemp3.push_back(10);

329     listTemp3.push_back(9);

330 

331     ShowList(listTemp2);

332     cout << endl;

333     ShowList(listTemp3);

334     cout << endl;

335 

336     // listTemp2.merge(listTemp3, greater<int>());    // 第二个参数可以是自己定义的函数如下

337     listTemp2.merge(listTemp3, myCmp);

338     ShowList(listTemp2);

339 }

340 

341 // splice()对两个链表进行结合(三个重载函数),结合后第二个链表清空

342 // void splice ( iterator position, list<T,Allocator>& x );

343 // void splice ( iterator position, list<T,Allocator>& x, iterator i );

344 // void splice ( iterator position, list<T,Allocator>& x, iterator first, iterator last );

345 void splice_test()

346 {

347     list<int> listTemp1(g_list1);

348     list<int> listTemp2(g_list2);

349 

350     ShowList(listTemp1);

351     ShowList(listTemp2);

352     cout << endl;

353     

354     // 

355     listTemp1.splice(++listTemp1.begin(), listTemp2);

356     ShowList(listTemp1);

357     ShowList(listTemp2);

358 

359     // 

360     listTemp1.assign(g_list1.begin(), g_list1.end());

361     listTemp2.assign(g_list2.begin(), g_list2.end());

362     listTemp1.splice(++listTemp1.begin(), listTemp2, ++listTemp2.begin());

363     ShowList(listTemp1);

364     ShowList(listTemp2);

365 

366     // 

367     listTemp1.assign(g_list1.begin(), g_list1.end());

368     listTemp2.assign(g_list2.begin(), g_list2.end());

369     listTemp1.splice(++listTemp1.begin(), listTemp2, ++listTemp2.begin(), listTemp2.end());

370     ShowList(listTemp1);

371     ShowList(listTemp2);

372 

373 }

374 

375 //  insert()在指定位置插入一个或多个元素(三个重载函数)

376 // iterator insert ( iterator position, const T& x );

377 // void insert ( iterator position, size_type n, const T& x );

378 // template <class InputIterator>

379 // void insert ( iterator position, InputIterator first, InputIterator last );

380 void insert_test()

381 {

382     list<int> listTemp1(g_list1);

383     ShowList(listTemp1);

384     listTemp1.insert(listTemp1.begin(), 51);

385     ShowList(listTemp1);

386     cout << endl;

387 

388     list<int> listTemp2(g_list1);

389     ShowList(listTemp2);

390     listTemp2.insert(listTemp2.begin(), 9, 51);

391     ShowList(listTemp2);

392     cout << endl;

393 

394     list<int> listTemp3(g_list1);

395     ShowList(listTemp3);

396     listTemp3.insert(listTemp3.begin(), g_list2.begin(), g_list2.end());

397     ShowList(listTemp3);

398 

399 }

400 

401 // swap()交换两个链表(两个重载)

402 void swap_test()

403 {

404     ShowList(g_list1);

405     ShowList(g_list2);

406     cout << endl;

407 

408     g_list1.swap(g_list2);

409     ShowList(g_list1);

410     ShowList(g_list2);

411 }

412 

413 bool same_integral_part (double first, double second)

414 { return ( int(first)==int(second) ); }

415 

416 // unique()删除相邻重复元素

417 void unique_test()

418 {

419     list<int> listTemp;

420     listTemp.push_back(1);

421     listTemp.push_back(1);

422     listTemp.push_back(4);

423     listTemp.push_back(3);

424     listTemp.push_back(5);

425     listTemp.push_back(1);

426     list<int> listTemp2(listTemp);

427     

428     ShowList(listTemp);

429     listTemp.unique();    // 不会删除不相邻的相同元素

430     ShowList(listTemp);

431     cout << endl;

432 

433     listTemp.sort();

434     ShowList(listTemp);

435     listTemp.unique();

436     ShowList(listTemp);

437     cout << endl;

438 

439     listTemp2.sort();

440     ShowList(listTemp2);

441     listTemp2.unique(same_integral_part);

442     ShowList(listTemp2);

443 

444 }

445 

446 // 主函数，下面要测试哪个就把那个注释去掉即可

447 int _tmain(int argc, _TCHAR* argv[])

448 {

449     InitList();

450 //     ShowList(g_list1);

451 //     ShowList(g_list2);

452 

453 //     constructor_test0();

454 //     constructor_test1();

455 //     constructor_test2();

456 //     constructor_test3();

457 //     constructor_test4();

458 //     assign_test();

459 //     operator_equality_test();

460 //     front_test7();

461 //     back_test();

462 //     begin_test();

463 //     end_test();

464 //     rbegin_test();

465 //     rend_test();

466 //     push_back_test();

467 //     push_front_test();

468 //     pop_back_test();

469 //     pop_front_test();

470 //     clear_test();

471 //     erase_test();

472 //      remove_test();

473 //     remove_if_test();

474 //     empty_test();

475 //     max_size_test();

476 //     resize_test();

477 //     reverse_test();

478 //     sort_test();

479 //     merge_test1();

480 //     merge_test2();

481 //     splice_test();

482 //     insert_test();

483 //     swap_test();

484 //     unique_test();

485     return 0;

486 }