STL 收拾（map、set、vector、list、stack、queue、deque、priority_queue）...

名人名言：生活得最有意义的人，并不就是年岁活得最长的人，而是对生活最有感受的人。——卢梭

　　　　SDAU-ACM耀哥收拾的，感触感染很不错，弄过来慢慢看

　　　　原文链接：http://blog.csdn.net/lmyclever/article/details/6750041

向量（vector） <vector>

连气儿存储的元素<vector>

Vector<int>c;

c.back（） 传回最后一个数据，不搜检这个数据是否存在。

c.clear（） 移除容器中所稀有据。

c.empty（） 断定容器是否为空。

c.front（） 传回地一个数据。

c.pop_back（） 删除最后一个数据。

c.push_back（elem） 在尾部参加一个数据。

c[i] 等同于 c.at（i）;

列表（list） <list>

由节点构成的双向链表，每个结点包含着一个元素<list>

list<int> list1（1，2，3）

front（）返回第一个元素的引用 int nRet =list1.front（） // nRet = 1

back（）返回最后一元素的引用 int nRet =list1.back（） // nRet = 3

push_back（）增长一元素到链表尾 list1.push_back（4） //list1（1，2，3，4）

push_front（）增长一元素到链表头 list1.push_front（4） //list1（4，1，2，3）

pop_back（）删除链表尾的一个元素 list1.pop_back（） //list1（1，2）

pop_front（）删除链表头的一元素 list1.pop_front（）　 //list1（2，3）

clear（）删除所有元素 list1.clear（）; // list1空了，list1.size（）=0

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）

（）在指定地位插入一个或多个元素

list1.（++list1.begin（），9）; // list1（1，9，2，3）

list1.（list1.begin（），2，9）; // list1（9，9，1，2，3）;

list1.（list1.begin（），list2.begin（），--list2.end（））;//list1（4，5，1，2，3）;

swap（）互换两个链表（两个重载）

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

unique（）删除相邻反复元素

L1（1，1，4，3，5，1）

L1.unique（）;// L1（1，4，3，5，1）

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现为空

reverse（）反转链表:list1.reverse（）; //list1（3，2，1）

remove（）删除链表中匹配值的元素（匹配元素全部删除）list对象L1（4，3，5，1，4）L1.remove（4）; //L1（3，5，1）;

empty（）断定是否链表为空bool bRet =L1.empty（）; //若L1为空，bRet = true，不然bRet = false。

rbegin（）返回链表最后一元素的后向指针（reverse_iteratoror const）list<int>::reverse_iterator it = list1.rbegin（）; //*it = 3

rend（）返回链表第一元素的下一地位的后向指针list<int>::reverse_iteratorit = list1.rend（）; // *（--riter） = 1

凑集（set） <set>

由节点构成的红黑树，每个节点都包含着一个元素，节点之间以某种感化于元素对的谓词分列，没有两个不合的元素可以或许拥有雷同的次序 <set>

set<type>: 以less<>为排序法例的set

set<type，op>: 以op为排序法例的set

struct op{

bool operator（）（const rec&a，const rec&b）{

return a.x<b.x||a.x==b.x&&a.y<b.y;

}

};

1.1 set：：begin

功能：返回第一个元素的定位器（iterator）的地址。

set <char>：：iterator cp;

ctr.（""a""）;

ctr.（""b""）;

cp=ctr.begin（）; //定位到ctr 的开端地位

1.2 set：：clear

功能：将一个set 容器的全部元素删除。

1.3 set：：count

功能：返回对应某个关键字的元素的个数。如同都是1吧

1.4 set：：empty

功能：测试一个set 容器是否为空。

1.5 set：：end

功能：返回最后一个元素后面的定位器（iterator）的地址。

1.7 set：：erase

功能：将一个或必然局限的元素删除。

1.8 set：：find

功能：求出与给定的关键字相等的元素的定位器。

set <string> ctr;

ctr.（"abc"）;

ctr.（"abcd"）;

ctr.（"abcf"）;

set <string>::iterator cp;

cp=ctr.find（"abc"）; //查找key=1 的元素

if（cp!=ctr.end（））

cout<<*cp <<endl;//显示abc

cp=ctr.find（"adf"）; //查找key=2 的元素

if（cp!=ctr.end（））

cout<<*cp <<endl;//不显示

cp=ctr.find（"gfv"）; //查找key=3 的元素

if（cp!=ctr.end（））

cout<<*cp <<endl;// 不显示

1.10 set：：

功能：将一个元素或者必然命量的元素插入到set 的特定地位中。

1.25 set：：upper_bound

功能：求出指向第一个关键字的值是大于一个给定值的元素的定位器。

cp=ctr.upper_bound（2）;//输出比2大的最小元素

多重凑集（multiset）< set>

容许存在两个次序相等的元素的凑集 <set>

multiset<type>: 以less<>为排序法例的multiset

multiset<type， op>: 以op为排序法例的multise

struct op{

bool operator（）（const rec&a，const rec&b）{

return a.x<b.x||a.x==b.x&&a.y<b.y;

}

};

multiset<int>h;

__typeof（h.begin（）） c=h.begin（）;//c指向h序列中第一个元素的地址，第一个元素是最小的元素

printf（"％d "，*c）;//将地址c存的数据输出

h.erase（c）;//从h序列中将c指向的元素删除

__typeof（）是个好器材~

栈（stack） <stack>

掉队先出的值的分列 <stack>

定义一个stack的变量stack<int> s;

入栈，如例：s.push（x）;

出栈，如例：s.pop（）;重视，出栈操纵只是删除栈顶元素，并不返回该元素。

接见栈顶，如例：s.top（）

断定栈空，如例：s.empty（），当栈空时，返回true。

接见栈中的元素个数，如例：s.size（）

队列（queue） <queue>

进步前辈先出的执的分列 <queue>

定义一个queue的变量 queue<Type> M
查看是否为空典范 M.empty（） 是的话返回1，不是返回0;
从已有元素后面增长元素M.push（）
输呈现有元素的个数 M.size（）
显示第一个元素 M.front（）
显示最后一个元素 M.back（）
清除第一个元素 M.pop（）

优先队列（priority_queue） <queue>

元素的次序是由感化于所存储的值对上的某种谓词决意的的一种队列 <queue>

1、默认从大到小

priority_queue<int> qi;

2、从小到大输出可以传入一个斗劲函数，应用functional.h函数对象作为斗劲函数，great<int>（小到大） less<int>（大到小）

priority_queue<int， vector<int>， greater<int> >qi2; 第二个参数为容器类型。第三个参数为斗劲函数。

3、自定义：

struct cmp // 最小优先队列

{

bool operator（）（const long long i，constlong long j）

{

return i>j;

}

};

priority_queue<int，vector<longlong>，cmp> Q;

struct node // 最小优先队列

{

int id，len;

bool operator < （const node &b）const// 只能重载小于号

{

return len>b.len;

}

};

priority_queue<node>Q;

Q.empty（） // 断定队列是否为空返回ture默示空返回false默示空 bool

Q.top（） // 返回顶端元素的值元素还在队列里

Q.pop（） // 删除顶端元素 void

Q.push（V） // 把long long型的数V参加到队列里它会制动前提V的地位void

Q.size（） // 返回队列里元素个数 unsigned int

双端队列（deque） <deque>

连气儿存储的指向不合元素的指针所构成的数组<deque>

deque<int>c

c.pop_back（） 删除最后一个数据。

c.pop_front（） 删除头部数据。

c.push_back（elem） 在尾部参加一个数据。

c.push_front（elem） 在头部插入一个数据。

c.clear（） 移除容器中所稀有据。

c.front（） 传回地一个数据。

c.back（） 传回最后一个数据，不搜检这个数据是否存在。

c.size（） 返回容器中实际数据的个数。

c.empty（） 断定容器是否为空。

c[i] 等同于 c.at（i）;

映射（map） 由{键，值}对构成的凑集 <map>

以某种感化于键对上的谓词分列 <map>

三种插入数据的办法（第一种和第二种是一样的，当map中有这个关键字时，操纵是插入不了数据的，用数组体式格式会覆盖以前该关键字对应的值）

1. map<int，string>mapStudent;

mapStudent.（pair<int，string>（1，"student_one"））;

mapStudent.（pair<int，string>（2，"student_two"））;

2. map<int，string>mapStudent;

mapStudent.（map<int，string>::value_type（1，"student_one"））;

mapStudent.（map<int，string>::value_type（2，"student_two"））;

3. map<int，string>mapStudent;

mapStudent[1]="student_one";

mapStudent[2]="student_two";

可以用pair来获得是否插入成功

map<int，string>mapStudent;

pair<map<int，string>::iterator，bool> _pair;

_pair=mapStudent.（pair<int，string>（1，"student_one"））;

if（_pair.second==true）

cout<<" Successfully"<<endl;

怎么知道当前已经插入了几许数据呢，可以用size函数，用法如下：int nSize=mapStudent.size（）;

清空map中的数据可以用clear（）函数，剖断map中是否稀有据可以用empty（）函数

要剖断一个数据（关键字）是否在map中呈现的办法斗劲多，这里给出三种数据查找办法

第一种：用count函数来剖断关键字是否呈现，其毛病是无法定位数据呈现地位，因为map的特点，一对一的映射关系，就决意了count函数的返回值只有两个，要么是0，要么是1，呈现的景象，返回1

map<int，string> mapStudent;

mapStudent.（pair<int，string>（1，"student_one"））;

mapStudent.（pair<int，string>（2，"student_two"））;

mapStudent.（pair<int，string>（3，"student_three"））;

int t1，t2;

t1=mapStudent.count（4）;

t2=mapStudent.count（1）;

第二种：用find函数来定位数据呈现地位，它返回的一个迭代器，当数据呈现时，它返回数据地点地位的迭代器

map<string，int>mapStudent;

mapStudent.（pair<string，int>（"student_one"，1））;

mapStudent.（pair<string，int>（"student_two"，2））;

mapStudent.（pair<string，int>（"student_three"，3））;

map<string，int>::iteratoriter;

charch[]="student_three";

iter=mapStudent.find（ch）;

if（iter!=mapStudent.end（））

cout<<"Find，the value is: "<<iter->second<<endl;

else

cout<<"Donot Find"<<endl;

清空map中的数据可以用clear（）函数，剖断map中是否稀有据可以用empty（）函数，它返回true则申明是空

//若是要删除，用迭代器删除

map<int，string>::iterator iter;

iter=mapStudent.find（1）;

mapStudent.erase（iter）;

//若是要删除，用关键字删除

intn=mapStudent.erase（1）;//若是删除了n会返回，不然返回

//用迭代器，成片的删除

mapStudent.erase（mapStudent.begin（），mapStudent.end（））;

//一下代码把全部map清空

mapStudent.erase（mapStudent.begin（），mapStudent.end（））;

排序

一、

＃include <map>

＃include <string>

using namespace std;

typedef struct tagStudentInfo

{

int nID;

string strName;

booloperator < （tagStudentInfo const& _A） const

{

//这个函数指定排序策略，按nID排序，若是nID相等的话，按strName排序

if（nID< _A.nID）

return true;

if（nID== _A.nID）

return strName.compare（_A.strName） < 0;

returnfalse;

}

}StudentInfo， *PStudentInfo; //学生信息

int main（）

{

//用学生信息映射分数

map<StudentInfo， int>mapStudent;

StudentInfo studentInfo;

studentInfo.nID = 1;

studentInfo.strName ="student_one";

mapStudent.（pair<StudentInfo， int>（studentInfo， 90））;

studentInfo.nID = 2;

studentInfo.strName ="student_two";

mapStudent.（pair<StudentInfo， int>（studentInfo， 80））;

}

二、

＃include <map>

＃include <string>

＃include <iostream>

using namespace std;

typedef struct tagStudentInfo

{

int nID;

string strName;

} StudentInfo， *PStudentInfo; //学生信息

struct sort

{

bool operator（） （StudentInfo const &_A， StudentInfo const &_B）const

{

if（_A.nID < _B.nID）

return true;

if（_A.nID == _B.nID）

return _A.strName.compare（_B.strName） < 0;

return false;

}

};

int main（）

{

//用学生信息映射分数

map<StudentInfo， int， sort>mapStudent;

StudentInfo studentInfo;

studentInfo.nID = 1;

studentInfo.strName = "student_one";

mapStudent.（pair<StudentInfo， int>（studentInfo， 90））;

studentInfo.nID = 2;

studentInfo.strName = "student_two";

mapStudent.（pair<StudentInfo， int>（studentInfo， 80））;

map<StudentInfo， int>::reverse_iterator iter;

for（iter=mapStudent.rbegin（）;iter!= mapStudent.rend（）;iter++）

cout<<iter->second<<endl;

}

多重映射（multimap） <map>

容许键对有相等的次序的映射 <map>

比如在德律风簿中雷同的人可以有两个以上德律风号码，文件体系中可以将多个符号链接映射到雷同的物理文件，或DNS办事器可以将几个URLs映射到雷同的IP地址。

查找

1. 直接找到每种键值的所有元素的第一个元素的游标。

经由过程函数：lower_bound（ const keytype& x ）， upper_bound（ const keytype&x ） 可以找到比指定键值x的小的键值的第一个元素和比指定键值x大的键值的第一个元素。返回值为该元素的游标。

细节：当达到键值x已经是最大时，upper_bound返回的是这个multimap的end游标。同理，当键值x已经是最小了，lower_bound返回的是这个multimap的begin游标。

2. 指定某个键值，进行遍历

可以应用上方的lower_bound和upper_bound函数进行游历，也可以应用函数equal_range。其返回的是一个游标对。游标对pair::first是由函数lower_bound获得的x的前一个值，游标对pair::second的值是由函数upper_bound获得的x的后一个值。

multimap<int，int>a;

a.（pair<int，int>（1，11））;

a.（pair<int，int>（1，12））;

a.（pair<int，int>（1，13））;

a.（pair<int，int>（2，21））;

a.（pair<int，int>（2，22））;

a.（pair<int，int>（3，31））;

a.（pair<int，int>（3，32））;

multimap<int，int>::iterator p_map;

pair<multimap<int，int>::iterator，multimap<int，int>::iterator> ret;

for（p_map = a.begin（） ; p_map != a.end（）;）

{

cout<<p_map->first<<" =>";

ret = a.equal_range（p_map->first）;

for（p_map= ret.first; p_map != ret.second; ++p_map）

cout<<" "<< （*p_map）.second;

cout<<endl;

}

生活得最有意义的人，并不就是年岁活得最长的人，而是对生活最有感受的人。——卢梭