STL List容器

转载http://www.cnblogs.com/fangyukuan/archive/2010/09/21/1832364.html

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

先看看他们的分类吧

标准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构造函数

list<int> L0; // 空链表

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

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

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

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)

bool same_integral_part (double first, double second)

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

L1.unique(same_integral_part);

例子：

 

// -------------------------------------------------------------------------

// 文件名 : list1.cpp

// 创建者 : 方煜宽

// 　邮箱 ： fangyukuan@gmail.com

// 创建时间 : 2010-9-19 15:58

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

//

// -------------------------------------------------------------------------

#include "stdafx.h"

#include <iostream>

#include <list>

using namespace std;

list<int> g_list1;

list<int> g_list2;

//////////////////////////////////////////////////////////////////////////

// 初始化全局链表

void InitList()

{

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

g_list1.push_back(1);

g_list1.push_back(2);

g_list1.push_back(3);

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

g_list2.push_front(6);

g_list2.push_front(5);

g_list2.push_front(4);

}

// 输出一个链表

void ShowList(list<int>& listTemp)

{

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

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

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

{

cout << *it << ' ';

}

cout << endl;

}

//////////////////////////////////////////////////////////////////////////

// 构造函数，空链表

void constructor_test0()

{

list<int> listTemp;

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

}

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

void constructor_test1()

{

list<int> listTemp(3);

ShowList(listTemp);

}

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

void constructor_test2()

{

list<int> listTemp(5, 1);

ShowList(listTemp);

}

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

void constructor_test3()

{

list<int> listTemp(g_list1);

ShowList(listTemp);

}

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

void constructor_test4()

{

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

ShowList(listTemp);

}

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

// template <class InputIterator>

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

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

void assign_test()

{

list<int> listTemp(5, 1);

ShowList(listTemp);

listTemp.assign(4, 3);

ShowList(listTemp);

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

ShowList(listTemp);

}

// operator=

void operator_equality_test()

{

g_list1 = g_list2;

ShowList(g_list1);

ShowList(g_list2);

}

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

void front_test7()

{

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

}

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

void back_test()

{

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

}

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

void begin_test()

{

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

cout << *++it1 << endl;

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

it2++;

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

cout << *it2 << endl; 

}

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

void end_test()

{

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

--it;

cout << *it << endl;

}

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

void rbegin_test()

{

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

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

{

cout << *it << ' ';

}

cout << endl;

}

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

void rend_test()

{

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

--it;

cout << *it << endl;

}

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

void push_back_test()

{

ShowList(g_list1);

g_list1.push_back(4);

ShowList(g_list1);

}

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

void push_front_test()

{

ShowList(g_list1);

g_list1.push_front(4);

ShowList(g_list1);

}

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

void pop_back_test()

{

ShowList(g_list1);

cout << endl;

g_list1.pop_back();

ShowList(g_list1);

}

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

void pop_front_test()

{

ShowList(g_list1);

cout << endl;

g_list1.pop_front();

ShowList(g_list1);

}

// clear()删除所有元素

void clear_test()

{

ShowList(g_list1);

g_list1.clear();

ShowList(g_list1);

}

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

void erase_test()

{

ShowList(g_list1);

g_list1.erase(g_list1.begin());

ShowList(g_list1);

cout << endl;

ShowList(g_list2);

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

ShowList(g_list2);

}

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

void remove_test()

{

ShowList(g_list1);

g_list1.push_back(1);

ShowList(g_list1);

g_list1.remove(1);

ShowList(g_list1);

}

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

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

void remove_if_test()

{

ShowList(g_list1);

g_list1.remove_if(myFun);

ShowList(g_list1);

}

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

void empty_test()

{

list<int> listTemp;

if (listTemp.empty())

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

else

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

}

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

void max_size_test()

{

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

cout << nMax << endl;

}

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

void resize_test()

{

ShowList(g_list1);

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

ShowList(g_list1);

cout << endl;

ShowList(g_list2);

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

ShowList(g_list2);

}

// reverse()反转链表

void reverse_test()

{

ShowList(g_list1);

g_list1.reverse();

ShowList(g_list1);

}

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

void sort_test()

{

list<int> listTemp;

listTemp.push_back(9);

listTemp.push_back(3);

listTemp.push_back(5);

listTemp.push_back(1);

listTemp.push_back(4);

listTemp.push_back(3);

ShowList(listTemp);

listTemp.sort();

ShowList(listTemp);

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

ShowList(listTemp);

}

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

void merge_test1()

{

list<int> listTemp2;

listTemp2.push_back(3);

listTemp2.push_back(4);

list<int> listTemp3;

listTemp3.push_back(9);

listTemp3.push_back(10);

ShowList(listTemp2);

cout << endl;

ShowList(listTemp3);

cout << endl;

listTemp2.merge(listTemp3);

ShowList(listTemp2);

}

bool myCmp (int first, int second)

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

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

void merge_test2()

{

list<int> listTemp2;

listTemp2.push_back(4);

listTemp2.push_back(3);

list<int> listTemp3;

listTemp3.push_back(10);

listTemp3.push_back(9);

ShowList(listTemp2);

cout << endl;

ShowList(listTemp3);

cout << endl;

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

listTemp2.merge(listTemp3, myCmp);

ShowList(listTemp2);

}

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

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

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

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

void splice_test()

{

list<int> listTemp1(g_list1);

list<int> listTemp2(g_list2);

ShowList(listTemp1);

ShowList(listTemp2);

cout << endl;

//

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

ShowList(listTemp1);

ShowList(listTemp2);

//

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

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

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

ShowList(listTemp1);

ShowList(listTemp2);

//

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

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

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

ShowList(listTemp1);

ShowList(listTemp2);

}

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

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

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

// template <class InputIterator>

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

void insert_test()

{

list<int> listTemp1(g_list1);

ShowList(listTemp1);

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

ShowList(listTemp1);

cout << endl;

list<int> listTemp2(g_list1);

ShowList(listTemp2);

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

ShowList(listTemp2);

cout << endl;

list<int> listTemp3(g_list1);

ShowList(listTemp3);

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

ShowList(listTemp3);

}

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

void swap_test()

{

ShowList(g_list1);

ShowList(g_list2);

cout << endl;

g_list1.swap(g_list2);

ShowList(g_list1);

ShowList(g_list2);

}

bool same_integral_part (double first, double second)

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

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

void unique_test()

{

list<int> listTemp;

listTemp.push_back(1);

listTemp.push_back(1);

listTemp.push_back(4);

listTemp.push_back(3);

listTemp.push_back(5);

listTemp.push_back(1);

list<int> listTemp2(listTemp);

ShowList(listTemp);

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

ShowList(listTemp);

cout << endl;

listTemp.sort();

ShowList(listTemp);

listTemp.unique();

ShowList(listTemp);

cout << endl;

listTemp2.sort();

ShowList(listTemp2);

listTemp2.unique(same_integral_part);

ShowList(listTemp2);

}

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

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

{

InitList();

// ShowList(g_list1);

// ShowList(g_list2);

// constructor_test0();

// constructor_test1();

// constructor_test2();

// constructor_test3();

// constructor_test4();

// assign_test();

// operator_equality_test();

// front_test7();

// back_test();

// begin_test();

// end_test();

// rbegin_test();

// rend_test();

// push_back_test();

// push_front_test();

// pop_back_test();

// pop_front_test();

// clear_test();

// erase_test();

// remove_test();

// remove_if_test();

// empty_test();

// max_size_test();

// resize_test();

// reverse_test();

// sort_test();

// merge_test1();

// merge_test2();

// splice_test();

// insert_test();

// swap_test();

// unique_test();

return 0;

}

STL List容器的更多相关文章

C++ STL vector容器学习
STL(Standard Template Library)标准模板库是C++最重要的组成部分,它提供了一组表示容器.迭代器.函数对象和算法的模板.其中容器是存储类型相同的数据的结构(如vector, ...
STL之容器适配器queue的实现框架
说明:本文仅供学习交流,转载请标明出处,欢迎转载! 上篇文章STL之容器适配器stack的实现框架已经介绍了STL是怎样借助基础容器实现一种经常使用的数据结构stack (栈),本文介绍下第二种STL ...
STL的容器算法迭代器的设计理念
1) STL的容器通过类模板技术,实现数据类型和容器模型的分离. 2) STL的迭代器技术实现了遍历容器的统一方法:也为STL的算法提供了统一性. 3) STL的函数对象实现了自定义数据类型的算法运算 ...
c++复习：STL之容器
1 STL的string 1 String概念 string是STL的字符串类型,通常用来表示字符串.而在使用string之前,字符串通常是用char*表示的.string与char*都可以用来表示字 ...
stl之容器、迭代器、算法几者之间的关系
转自:https://blog.csdn.net/bobodem/article/details/49386131 stl包括容器.迭代器和算法: 容器用于管理一些相关的数据类型.每种容器都有它的优 ...
STL Queue 容器
STL Queue 容器 Queue简介 queue是队列容器,是一种“先进先出”的容器. queue是简单地装饰deque容器而成为另外的一种容器. # ...
STL stack 容器
STL stack 容器 Stack简介 stack是堆栈容器,是一种“先进后出”的容器. stack是简单地装饰deque容器而成为另外的一种容器. #include <s ...
STL Deque 容器
STL Deque 容器 Deque简介 deque是“double-ended queue”的缩写,和vector一样都是STL的容器,deque是双端的,而vector是单端的. ...
浅谈C++ STL string容器
浅谈C++ STL string容器本篇随笔简单讲解一下\(C++STL\)中\(string\)容器的使用方法及技巧. string容器的概念其实\(string\)并不是\(STL\)的一种容 ...

随机推荐

redis 学习笔记一
找了半天,发觉还是redis的源码看起来比较舒服.所以决定今年把redis的源码读一遍顺便做个读书笔记.好好记录下.话说现在越来不越不愿意用脑袋来记录东西,喜欢靠note来记.话说这样不爱用脑会不会过 ...
c语言for语句
首先呢 for语句是由4部分组成 for(表达式1;表达式2;表达式3) 循环体: 注意 1:循环中的表达式用;隔开表达式1通常用来呢赋初值表达式2通常用来循环控制也就是循环条件表达式3通常就是 ...
C# - List操作 - 按照字母排序
有Family的类如下: public class FamilyModel { public string Name { set; get; } } 创建List List<FamilyMode ...
Java IO 概述
输入和输出-数据源和目标媒介术语“输入”和“输出”有时候会有一点让人疑惑.一个应用程序的输入往往是另一个应用程序的输出.那么OutputStream流到底是一个输出到目的地的流呢,还是一个产生输出的 ...
Direct3D 11的资源
资源(Resource) 如果把渲染流水线比喻成汽车装配线,资源就是流水线上需要输入的东西. 资源可分为两类:Textures(纹理)和Buffers(缓冲区). Textures可以简单地分为1维, ...
使用markdown语法撰写csdn博客
在CSDN之下写blog无疑是一件非常吃力的事情,对于非常多simple爱好者来讲,能用markdown语法来书写代码是最优雅简洁只是的了.本文主要介绍markdown语法和怎样它来撰写csdn下的b ...
JavaScript总结（二）系统分析
学习Javascript的时候.遇到了一个问题. 看了牛腩的视频,感觉讲的太简单和基础,像认识一位新朋友.但仅有一面之缘就结束了. 再看姜浩的视频.又看得迷迷糊糊,让我找到了当初看两位台湾专家讲VB. ...
Sybase自增字段跳号的解决方法
Sybase自增字段跳号原因及影响: 在Sybase数据库中如果数据库在开启的情况下,因为非正常的原因(死机.断电)而导致数据库服务进程强制结束. 那么自动增长的字段将会产生跳号的情况,再往数据表里面 ...
mysql三种binlog日志的理解
最近,一直在纠结要不要改数据库binlog的日志格式,原先用的是row格式,导致数据库binlog日志较大,磁盘空间本来也不是很大,所以就想看看能不能改变binlog日志.在该binlog日志之前,先 ...
vsftp虚拟用户登录配置详解
一.安装:1.安装Vsftpd服务:# yum install vsftpd 2.安装DB4部件包:这里要特别安装一个db4的包,用来支持文件数据库.# yum install db4-utils 二 ...

STL List容器

先看看他们的分类吧

list

STL List容器的更多相关文章

随机推荐

热门专题