STL中常用容器总结

大家好，欢迎来到IT知识分享网。

1.vector(向量)(底层是数组)

向量没有确定数据类型所以向量可以是多种数据类型，但是注意一个向量对象只能有一种数据类型，可以构造二维向量（二维数组）比如二维整型向量vector ，但值得注意的是二维向量的大元素和小元素（行元素和最小元素）都是一个向量可以不分配大小而是通过数据的规模分配大小

这里介绍整型向量的常用方法函数（其他类型的可以自行通过转换类型达到相同的效果）：

template <typename Container> void Show(Container &con) { Container::iterator it = con.begin(); for(; it != con.end();++it) { cout<<*it<<" "; } cout<<endl; } template <typename Container> bool Del_Container1(Container &con,int val) { if(con.empty()) { return false ; } Container::iterator it = con.begin(); for( it ; it != con.end();) { if(*it == val) { it = con.erase(it); } else { ++it; } } return true; } template <typename Container> bool Del_Container2(Container &con,int val) { Container::iterator it = con.begin(); int count = 0 ; sort(con.begin(),con.end()); for( it ; it != con.end();++it) { if(*it == val) { break; } } //排序后，用pos标记要删的数字的第一个位置； Container:: iterator pos = it; //从标记位开始找要删数字的个数 for(it = pos ; it != con.end();++it) { if(*it == val) { count++; } } //it指向要删数字区间的最后一个； it = pos+3; //留出一个数字 删除后面的区间内的所有元素 con.erase(pos+1,it); return true ; } template <typename Container> bool Del_Container3(Container &con,int val) { if(con.empty()) return false; sort(con.begin(),con.end()); Container::iterator it = unique(con.begin(),con.end()); //unique(begin.end),表示一定区间，通过相邻比较删除重复的元素，但是不会真正的删除，而是会放到尾地址后面 //unique函数会将重复出现的数字放在容器的末尾并返回第一个重复的数字的迭代器 //再用erase函数擦除从指向的元素到最后的元素 con.erase(it,con.end()); return true; } int main() { int row; cin>>row; int col; cin>>col; vector<vector<int>> array(row); for(int i = 0 ; i < row ; ++i) { array[i].resize(col); } for(int i = 0 ; i < row ;++i) { for(int j = 0 ; j < col ;++j) { cin>>array[i][j]; } } int arr[] = {1,2,3,4,2,6,2,2,2,3,3,3,3,7,8,2}; int len = sizeof(arr)/sizeof(arr[0]); vector<int> vec(arr,arr+len); cout<<"删除前vector中的元素"<<" "; Show(vec); Del_Container1(vec,2); cout<<"删除后vector中的元素"<<" "; Show(vec); return 0; } 

#include <vector> using std::vector 

vector不是一种数据类型，而只是一个类模版，可以用来定义多种数据类型。在定义了vector对象之后，vector类型的每一种都指定了其保存元素的类型。例如：使用的vector和vector都是数据类型。

• vector对象的定义及初始化

vector<type> vec1; / v1保存类型为type的对象，默认构造函数，v1为空 vector<type> vec2(size); / v2含有值初始化的元素的size个副本 vector<type> vec3(size,value); / v3包含值为value的size个元素 vector<type> vec4(myvector); / v4是myvector的一个副本 vector<type> vec5(first,last); / 用迭代器first和last之间的元素创建v5 

• vector与Array的转换

v.empty()：如果v为空，则返回true，否则返回false。 v.size()：返回v中元素的个数。 v.push_back(t)：在v的末尾增加一个值为t的元素。 v[n]：返回v中位置为n的元素。 v1=v2：把v1的元素替换成v2中元素的副本。 v1==v2：如果v1与v2相等，则返回true。 !=, <, <=, >, >=：保持这些操作符惯有的含义。 

• 容器的容器与2维数组

因为容器受容器元素类型的约束，所以可定义元素是容器类型的容器。例如，可以定义 vector 类型的容器 lines，其元素为 string 类型的 vector 对象：

vector< vector<string> > lines; /这里需要特别说明的是C++11中已经不在使用两个空格隔开相邻的>符号 

声明容器的容器，必须用空格隔开两个相邻的 > 符号，以示这是两个分开的符号，否则，系统会认为 >> 是单个符号，为右移操作符，并导致编译时错误。

vector<vector<int> > mat(3, vector<int>(4)); 

mat含有3个元素，每个元素是含有4个int值的向量，mat.size()是3 ，即3行。这个用法即相当于一个2维数组。

• vector元素的常用操作

• c.max_size()：返回向量类型的最大容量（2^30-1=0x3FFFFFFF）
• c.capacity()：返回向量当前开辟的空间大小（<= max_size，与向量的动态内存分配策略相关）。
• c.size()：返回向量中现有元素的个数（<=capacity）。
• c.resize(n)：调整向量的长度使其能容纳n个元素。
• c.resize(n,x)：把向量的大小改为n，所有新元素的初值赋为x。
• c.empty()：如果向量为空，返回真。

元素的赋值操作
c.assign(first,last)：将迭代器first,last所指定范围内的元素复制到c 中。
c.assign(num,val)：用val的num份副本重新设置c。
元素的访问操作
c.at(n)：等价于下标运算符[]，返回向量中位置n的元素，因其有越界检查，故比[ ]索引访问安全。
c.front()：返回向量中第一个元素的引用。
c.back()：返回向量中最后一个元素的引用。
c.begin()：返回向量中第一个元素的迭代器。
c.end()：返回向量中最后一个元素的下一个位置的迭代器，仅作结束游标，不可解引用。
c.rbegin()：返回一个反向迭代器，该迭代器指向容器的最后一个元素。
c.rend()：返回一个反向迭代器，该迭代器指向容器第一个元素前面的位置。
元素的删除操作
c.pop_back()：删除向量最后一个元素。
c.clear()：删除向量中所有元素。
c.erase(iter)：删除迭代器iter所指向的元素，返回一个迭代器指向被删除元素后面的元素。
c.erase(start, end)：删除迭代器start、end所指定范围内的元素，返回一个迭代器指向被删除元素段后面的元素。
元素的插入操作
c.push_back(x)：把x插入到向量的尾部。
c.insert(iter, x)：在迭代器iter指向的元素之前插入值为x的新元素，返回指向新插入元素的迭代器。
c.insert(iter,n,x)：在迭代器iter指向的元素之前插入n个值为x的新元素，返回void。
c.insert(iter,start,end)：把迭代器start和end所指定的范围内的所有元素插入到迭代器iter所指向的元素之前，返回void。
元素的交换操作
c.reverse()：反转元素顺序。
c.swap(c2)：交换2个向量的内容，c和c2 的类型必须相同。

• 顺序访问vector的几种方式

1、向向量a中添加元素

vector<int> a; for(int i=0;i<10;i++) a.push_back(i); 

2、也可以从数组中选择元素向向量中添加

int a[6]={1,2,3,4,5,6}; vector<int> b； for(int i=1;i<=4;i++) b.push_back(a[i]); 

3、也可以从现有向量中选择元素向向量中添加

int a[6]={1,2,3,4,5,6}; vector<int> b; vector<int> c(a,a+4); for(vector<int>::iterator it=c.begin();it<c.end();it++) b.push_back(*it); 

• 从向量中读取元素
  1、通过下标方式读取
  

int a[6]={1,2,3,4,5,6}; vector<int> b(a,a+4); for(int i=0;i<=b.size()-1;i++) cout<<b[i]<<" "; 

2、通过遍历器方式读取

int a[6]={1,2,3,4,5,6}; vector<int> b(a,a+4); for(vector<int>::iterator it=b.begin();it!=b.end();it++) cout<<*it<<" "; 

• 几种重要的算法

使用时需要包含头文件：#include<algorithm>
（1）sort(a.begin(),a.end()); //对a中的从a.begin()（包括它）到a.end()（不包括它）的元素进行从小到大排列
（2）reverse(a.begin(),a.end()); //对a中的从a.begin()（包括它）到a.end()（不包括它）的元素倒置，但不排列，如a中元素为1,3,2,4,倒置后为4,2,3,1
（3）copy(a.begin(),a.end(),b.begin()+1); //把a中的从a.begin()（包括它）到a.end()（不包括它）的元素复制到b中，从b.begin()+1的位置（包括它）开始复制，覆盖掉原有元素
（4）find(a.begin(),a.end(),10); //在a中的从a.begin()（包括它）到a.end()（不包括它）的元素中查找10，若存在返回其在向量中的位置

2.string(字符串)

3.set（集合）（底层红黑树）

set即为一个红黑树（是一种自平衡二叉查找树，红黑树和AVL树类似，都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能.它虽然是复杂的，但它的最坏情况运行时间也是非常良好的可以在O(log n)时间内做查找，插入和删除，这里的n 是树中元素的数目），其作用是将排入的数据自动进行去重并且按照树的特性（左孩子的值一定比父节点的小，右孩子的值一定比父节点大） 可起到二分搜索的一个作用，但是这里一般常用的是查找是否右一个值在set里面和去重

find() ，返回给定值值得定位器并赋值给迭代器，如果没找到则返回end()。

set<int> s; ...... set<int>::reverse_iterator rit; for(rit=s.rbegin();rit!=s.rend();rit++) 

4.元素删除：与插入一样，可以高效的删除，并自动调整使红黑树平衡。

set<int> s; s.erase(2); //删除键值为2的元素 s.clear(); 

5.元素检索：find()，若找到，返回该键值迭代器的位置，否则，返回最后一个元素后面一个位置。

set<int> s; set<int>::iterator it; it=s.find(5); //查找键值为5的元素 if(it!=s.end()) //找到 cout<<*it<<endl; else //未找到 cout<<"未找到"; 

6.自定义比较函数

//自定义比较函数myComp,重载“（）”操作符

struct myComp { bool operator()(const your_type &a,const your_type &b) { return a.data-b.data>0; } } set<int,myComp>s; ...... set<int,myComp>::iterator it; 

(2)如果元素是结构体，可以直接将比较函数写在结构体内。

例：

struct Info { string name; float score; //重载“<”操作符，自定义排序规则 bool operator < (const Info &a) const { //按score从大到小排列 return a.score<score; } } set<Info> s; ...... set<Info>::iterator it; 

4.priority_queuqe(优先队列)（底层为大根堆小根堆）

priority_queue的底层为堆，大根堆（根节点的值是整个堆最大的，所有的子节点都比父节点的值小）和小根堆（根节点的值是整个堆最小的，所有的子节点都比父节点大）

empty() 　　 如果队列为空，则返回真

pop()　　　　删除对顶元素，删除第一个元素

push() 　　 加入一个元素

size() 　　　 返回优先队列中拥有的元素个数

top() 　　　　返回优先队列对顶元素，返回优先队列中有最高优先级的元素

1、普通方法：

priority_queue<(队列中元素的数据类型), (用于储存和访问队列元素的底层容器的类型), (比较规则) > k ——

(标准式)定义一个有序队列

例如：priority_queue<int, vector, greater > k;(注意:比较规则后面必须要空上一格) ->定义一个有序队列，

排序规则为从大到小（其顶端元素为最小的那个）（greater为从小到大，顶端最小，less为从大到小，顶端最大）

k.empty() —— 查看是否为空范例,是的话返回1,不是返回0

k.push(i) —— 从已有元素后面增加元素i(队伍大小不预设)

k.pop() —— 清除位于顶端的元素(当然是排完序后,下同)

k.top() —— 显示顶端的元素

土堆总质量的体力，请问你至少需要多少体力才可以将所有土堆合成一个

输入样例： 对应输出：

10 105

8

1 2 8 7 6 9 2 3

思路：很显然，每次都将当前最轻的两个土堆合成一个大土堆即可

代码

#include<iostream> #include<cstdio> #include<queue> using namespace std; int main(void) { int T, n, x, i, a, b; long long sum; scanf("%d", &T); while(T--) { sum = 0; priority_queue<int, vector<int>, greater<int> > q; /*建立一个队列,其中队列顶端为最小值*/ scanf("%d", &n); for(i=1;i<=n;i++) { scanf("%d", &x); q.push(x); } while(q.empty()==0) { a = q.top(); /*弹出质量最小的两个土堆并合并*/ q.pop(); if(q.empty()==1) /*当然如果只剩下一个土堆了就结束*/ break; b = q.top(); q.pop(); q.push(a+b); /*合并之后入队*/ sum += a+b; } printf("%lld\n", sum); } return 0; } 

5.queue(队列)（底层list或者deque）

C++队列queue模板类的定义在<queue>头文件中,queue 模板类需要两个模板参数，一个是元素类型，一个容器类型，元素类型是必要的，容器类型是可选的，默认为deque 类型。 C++队列Queue是一种容器适配器，它给予程序员一种先进先出(FIFO)的数据结构。 

C++队列Queue类成员函数如下:

back() 返回最后一个元素

empty() 如果队列空则返回真

front() 返回第一个元素

pop() 删除第一个元素

push() 在末尾加入一个元素

size() 返回队列中元素的个数

定义queue 对象的示例代码如下：

 queue<int> q1; queue<double> q2; 

queue 的基本操作举例如下：

queue入队，如例：q.push(x); 将x 接到队列的末端。

queue出队，如例：q.pop(); 弹出队列的第一个元素，注意，并不会返回被弹出元素的值。

访问queue队首元素，如例：q.front()，即最早被压入队列的元素。

访问queue队尾元素，如例：q.back()，即最后被压入队列的元素。

判断queue队列空，如例：q.empty()，当队列空时，返回true。

#include <cstdlib> #include <iostream> #include <queue> using namespace std; int main() { int e,n,m; queue<int> q1; for(int i=0;i<10;i++) q1.push(i); if(!q1.empty()) cout<<"dui lie bu kong\n"; n=q1.size(); cout<<n<<endl; m=q1.back(); cout<<m<<endl; for(int j=0;j<n;j++) { e=q1.front(); cout<<e<<" "; q1.pop(); } cout<<endl; if(q1.empty()) cout<<"dui lie bu kong\n"; system("PAUSE"); return 0; } 

C++ stl队列queue示例代码2:

#include <iostream> #include <queue> #include <assert.h> /* 调用的时候要有头文件： #include<stdlib.h> 或 #include<cstdlib> + #include<queue> #include<queue> 详细用法: 定义一个queue的变量 queue<Type> M 查看是否为空范例 M.empty() 是的话返回1，不是返回0; 从已有元素后面增加元素 M.push() 输出现有元素的个数 M.size() 显示第一个元素 M.front() 显示最后一个元素 M.back() 清除第一个元素 M.pop() */ using namespace std; int _tmain(int argc, _TCHAR* argv[]) { queue <int> myQ; cout<< "现在 queue 是否 empty? "<< myQ.empty() << endl; for(int i =0; i<10 ; i++) { myQ.push(i); } for(int i=0; i<myQ.size(); i++) { printf("myQ.size():%d\n",myQ.size()); cout << myQ.front()<<endl; myQ.pop(); } system("PAUSE"); return 0; } 

输出结果：

现在 queue 是否 empty? 1

myQ.size():10

0

myQ.size():9

1

myQ.size():8

2

myQ.size():7

3

myQ.size():6

4

请按任意键继续. . .

（二）deque双端队列

template <typename Container> void Show(Container &con) { Container::iterator it = con.begin(); for(; it != con.end();++it) { cout<<*it<<" "; } cout<<endl; } template <typename Container> bool Del_Container1(Container &con,int val) { if(con.empty()) { return false ; } Container::iterator it = con.begin(); for( it ; it != con.end();) { if(*it == val) { it = con.erase(it); } else { ++it; } } return true; } int main() { deque<int> dq1(10,5); deque<int>::iterator it = dq1.begin(); for(; it != dq1.end();++it) cout<<*it<<" "; cout<<endl; int arr[] = {1,2,3,4,5,6,7,8,1,2,1,2,2,2}; int len = sizeof(arr)/sizeof(arr[0]); deque<int> dq2(arr,arr+len); Show(dq2); dq2.pop_back(); Show(dq2); return 0; } 

1、声明deque容器

#include<deque> / 头文件 deque<type> deq; / 声明一个元素类型为type的双端队列que deque<type> deq(size); / 声明一个类型为type、含有size个默认值初始化元素的的双端队列que deque<type> deq(size, value); / 声明一个元素类型为type、含有size个value元素的双端队列que deque<type> deq(mydeque); / deq是mydeque的一个副本 deque<type> deq(first, last); / 使用迭代器first、last范围内的元素初始化deq 

2、deque的常用成员函数

deque<int> deq; 

• deq[ ]：用来访问双向队列中单个的元素。
• deq.front()：返回第一个元素的引用。
• deq.back()：返回最后一个元素的引用。
• deq.push_front(x)：把元素x插入到双向队列的头部。
• deq.pop_front()：弹出双向队列的第一个元素。
• deq.push_back(x)：把元素x插入到双向队列的尾部。
• deq.pop_back()：弹出双向队列的最后一个元素。
  3、deque的一些特点
  
• 支持随机访问，即支持[ ]以及at()，但是性能没有vector好。
• 可以在内部进行插入和删除操作，但性能不及list。
• deque两端都能够快速插入和删除元素，而vector只能在尾端进行。
• deque的元素存取和迭代器操作会稍微慢一些，因为deque的内部结构会多一个间接过程。
• deque迭代器是特殊的智能指针，而不是一般指针，它需要在不同的区块之间跳转。
• deque可以包含更多的元素，其max_size可能更大，因为不止使用一块内存。
• deque不支持对容量和内存分配时机的控制。
• 在除了首尾两端的其他地方插入和删除元素，都将会导致指向deque元素的任何pointers、
• references、iterators失效。不过，deque的内存重分配优于vector，因为其内部结构显示不需要复制所有元素。
• deque的内存区块不再被使用时，会被释放，deque的内存大小是可缩减的。不过，是不是这么做以及怎么做由实际操作版本定义。
• deque不提供容量操作：capacity()和reverse()，但是vector可以。

6.map(映射)(底层为红黑树)

iter = mapStudent.find(“r123”)//和以往的find的返回值相同如果额米有查询到就返回end(),如果右就返回其所在地址

int n = mapStudent.erase(“r123”);//关键字删除，如果刪除了會返回1，否則返回0

 map<string , int >mapstring; map<int ,string >mapint; map<string, char>mapstring; map< char ,string>mapchar; map<char ,int>mapchar; map<int ,char >mapint； 

2. map添加数据：
给map容器添加元素可通过两种方式实现：

• 通过insert成员函数实现。
• 通过下标操作符获取元素，然后给获取的元素赋值。 map对象的访问可通过下标和迭代器两种方式实现：
• map的下标是键，返回的是特定键所关联的值。
• 使用迭代器访问，iter->first指向元素的键，iter->second指向键对应的值。
  使用下标访问map容器与使用下标访问vector的行为截然不同：用下标访问map中不存在的元素将导致在map容器中添加一个新的元素，这个元素的键即为该下标值，键所对应的值为空。
  如：
  
  

 map<int ,string> maplive; 1.maplive.insert(pair<int,string>(102,"aclive")); 2.maplive.insert(map<int,string>::value_type(321,"hai")); 3, maplive[112]="April"; /map中最简单最常用的插入添加！ 

3，map中元素的查找：
find()函数返回一个迭代器指向键值(就是键，值在这里叫做实值)为key的元素，如果没找到就返回指向map尾部的迭代器。

map<int ,string >::iterator l_it;; l_it=maplive.find(112); if(l_it==maplive.end()) cout<<"we do not find 112"<<endl; else cout<<"wo find 112"<<endl; 

4,map中元素的删除：
如果删除112；

map<int ,string >::iterator l_it;; l_it=maplive.find(112); if(l_it==maplive.end()) cout<<"we do not find 112"<<endl; else maplive.erase(l_it); //delete 112; 

5,map中 swap的用法：
Map中的swap不是一个容器中的元素交换，而是两个容器交换；

For example：

#include <map> #include <iostream> using namespace std; int main( ) { map <int, int> m1, m2, m3; map <int, int>::iterator m1_Iter; m1.insert ( pair <int, int> ( 1, 10 ) ); m1.insert ( pair <int, int> ( 2, 20 ) ); m1.insert ( pair <int, int> ( 3, 30 ) ); m2.insert ( pair <int, int> ( 10, 100 ) ); m2.insert ( pair <int, int> ( 20, 200 ) ); m3.insert ( pair <int, int> ( 30, 300 ) ); cout << "The original map m1 is:"; for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ ) cout << " " << m1_Iter->second; cout << "." << endl; // This is the member function version of swap //m2 is said to be the argument map; m1 the target map m1.swap( m2 ); cout << "After swapping with m2, map m1 is:"; for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ ) cout << " " << m1_Iter -> second; cout << "." << endl; cout << "After swapping with m2, map m2 is:"; for ( m1_Iter = m2.begin( ); m1_Iter != m2.end( ); m1_Iter++ ) cout << " " << m1_Iter -> second; cout << "." << endl; // This is the specialized template version of swap swap( m1, m3 ); cout << "After swapping with m3, map m1 is:"; for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ ) cout << " " << m1_Iter -> second; cout << "." << endl; } 

#include <map> #include <iostream> using namespace std; int main( ) { map <int, int> m1; map <int, int>::iterator m1_Iter; m1.insert ( pair <int, int> ( 1, 20 ) ); m1.insert ( pair <int, int> ( 4, 40 ) ); m1.insert ( pair <int, int> ( 3, 60 ) ); m1.insert ( pair <int, int> ( 2, 50 ) ); m1.insert ( pair <int, int> ( 6, 40 ) ); m1.insert ( pair <int, int> ( 7, 30 ) ); cout << "The original map m1 is:"<<endl; for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ ) cout << m1_Iter->first<<" "<<m1_Iter->second<<endl; } 

7， map的基本操作函数：
C++ Maps是一种关联式容器，包含“关键字/值”对
begin() 返回指向map头部的迭代器
clear(） 删除所有元素
count() 返回指定元素出现的次数
empty() 如果map为空则返回true
end() 返回指向map末尾的迭代器
equal_range() 返回特殊条目的迭代器对
erase() 删除一个元素
find() 查找一个元素
get_allocator() 返回map的配置器
insert() 插入元素
key_comp() 返回比较元素key的函数
lower_bound() 返回键值>=给定元素的第一个位置
max_size() 返回可以容纳的最大元素个数
rbegin() 返回一个指向map尾部的逆向迭代器
rend() 返回一个指向map头部的逆向迭代器
size() 返回map中元素的个数
swap() 交换两个map
upper_bound() 返回键值>给定元素的第一个位置
value_comp() 返回比较元素value的函数

8.map容器和哈希表 ：
对于map容器，使用其下标行为一次访问一系列的相同类型的元素，则可以将这个过程理解为构造了这些元素的一个哈希表，以统计输入单词的出现次数为例：

map<string, int> word_count; string word; while(cin>>word) ++word_count[word]; // 相当于生成了一个哈希表word_count 

简单的说，就是键（本例中为string）会被作为数组的下标，值（本例中为int）则为该下标所对应的数组元素的值

7.list(链表)（底层双向链表）

一.list的定义
List是stl实现的双向链表，与向量(vectors)相比, 它允许快速的插入和删除，但是随机访问却比较慢。使用时需要添加头文件

#include <list> 

二.List定义和初始化：

list<int>lst1; //创建空list list<int> lst2(5); //创建含有5个元素的list list<int>lst3(3,2); //创建含有3个元素的list list<int>lst4(lst2); //使用lst2初始化lst4 list<int>lst5(lst2.begin(),lst2.end()); //同lst4 

三.List常用操作函数：
Lst1.assign() 给list赋值
Lst1.back() 返回最后一个元素
Lst1.begin() 返回指向第一个元素的迭代器
Lst1.clear() 删除所有元素
Lst1.empty() 如果list是空的则返回true
Lst1.end() 返回末尾的迭代器
Lst1.erase() 删除一个元素
Lst1.front() 返回第一个元素
Lst1.get_allocator() 返回list的配置器
Lst1.insert() 插入一个元素到list中
Lst1.max_size() 返回list能容纳的最大元素数量
Lst1.merge() 合并两个list
Lst1.pop_back() 删除最后一个元素
Lst1.pop_front() 删除第一个元素
Lst1.push_back() 在list的末尾添加一个元素
Lst1.push_front() 在list的头部添加一个元素
Lst1.rbegin() 返回指向第一个元素的逆向迭代器
Lst1.remove() 从list删除元素
Lst1.remove_if() 按指定条件删除元素
Lst1.rend() 指向list末尾的逆向迭代器
Lst1.resize() 改变list的大小
Lst1.reverse() 把list的元素倒转
Lst1.size() 返回list中的元素个数
Lst1.sort() 给list排序
Lst1.splice() 合并两个list
Lst1.swap() 交换两个list
Lst1.unique() 删除list中重复的元素
四、List使用示例：
示例1：遍历List

//迭代器法 

 for(list<int>::const_iteratoriter = lst1.begin();iter != lst1.end();iter++) { cout<<*iter; } cout<<endl; 

示例2：

#include <iostream> #include <list> #include <numeric> #include <algorithm> #include <windows.h> using namespace std; typedef list<int> LISTINT; typedef list<int> LISTCHAR; void main() { //用LISTINT创建一个list对象 LISTINT listOne; //声明i为迭代器 LISTINT::iterator i; listOne.push_front(3); listOne.push_front(2); listOne.push_front(1); listOne.push_back(4); listOne.push_back(5); listOne.push_back(6); cout << "listOne.begin()--- listOne.end():" << endl; for (i = listOne.begin(); i != listOne.end(); ++i) cout << *i << " "; cout << endl; LISTINT::reverse_iterator ir; cout << "listOne.rbegin()---listOne.rend():" << endl; for (ir = listOne.rbegin(); ir != listOne.rend(); ir++) { cout << *ir << " "; } cout << endl; int result = accumulate(listOne.begin(), listOne.end(), 0); //accumulate: 以init为初值，对迭代器给出的值序列做累加，返回累加结果值， cout << "Sum=" << result << endl; cout << "------------------" << endl; //用LISTCHAR创建一个list对象 LISTCHAR listTwo; //声明i为迭代器 LISTCHAR::iterator j; listTwo.push_front('C'); listTwo.push_front('B'); listTwo.push_front('A'); listTwo.push_back('D'); listTwo.push_back('E'); listTwo.push_back('F'); cout << "listTwo.begin()---listTwo.end():" << endl; for (j = listTwo.begin(); j != listTwo.end(); ++j) cout << char(*j) << " "; cout << endl; j = max_element(listTwo.begin(), listTwo.end()); cout << "The maximum element in listTwo is: " << char(*j) << endl; Sleep(10000); //这是windows里的延时函数，这里作用是主函数运行完之后10s后程序才停止 } 

8.stack(栈)（底层为list或者deque）

栈stack
c++ stl栈stack介绍c++ Stack（堆栈） 是一个容器类的改编，为程序员提供了堆栈的全部功能，——也就是说实现了一个先进后出（FILO）的数据结构。
c++ stl栈stack的头文件为:

#include <stack> 

c++ stl栈stack的成员函数介绍

操作 比较和分配堆栈

empty() 堆栈为空则返回真

pop() 移除栈顶元素

push() 在栈顶增加元素

size() 返回栈中元素数目

top() 返回栈顶元素

c++ stl栈stack用法代码举例1

#include <iostream> #include <stack> using namespace std; int main () { stack<int> mystack; int sum (0); for (int i=1;i<=10;i++) mystack.push(i); while (!mystack.empty()) { sum += mystack.top(); mystack.pop(); } cout << "total: " << sum << endl; return 0; } 

c++ stl栈stack用法代码举例2

#include <iostream> #include <stack> using namespace std; int main () { stack<int> mystack; for (int i=0; i<5; ++i) mystack.push(i); cout << "Popping out elements..."; while (!mystack.empty()) { cout << " " << mystack.top(); mystack.pop(); } cout << endl; return 0; }