STL容器的常用用法

STL：

1.vector：

vector<int> v;
vector<int> v(10);//定义大小为10的int型向量容器。
vector<int> v(10,3);//定义大小为10，每个元素为3。

v.push_back(2);//尾部添加元素2.

v.pop_back();//尾部删除一个元素.

v[0]=2;
v[1]=3;//下标访问。

vector<int>::iterator it;//迭代器访问
for(it=v.begin();it!=v.end();it++)
{
cout<<*it<<" ";
}

//元素插入，插入位置必须是迭代器位置
v.insert(v.begin(),8);//最前面插入
v.insert(v.begin()+2,8);
v.insert(v.end(),8);//末尾追加

//元素删除
v.erase(v.begin()+2);//删除第2+1个元素
v.erase(v.begin()+1,v.begin()+5);//删除迭代器第一到第五区间的所有元素
v.clear();//删除所有元素

reverse(v.begin(),v.end());//反向排列向量所有元素（可以反向排列某段迭代器区间元素）

sort(v.begin(),v.end());//sort排序（默认升序排列）

//设计排序比较函数
bool comp(const int& a,const int& b)
{
return a>b;//降序排列
}
sort(v.begin(),v.end(),comp);

v.size();//返回向量大小,即元素个数
v.empty();//判空，空时返回1，不空时返回0。

2.stack：

//堆栈容器

stack<int> s;
s.push(1);//入栈
s.pop();//出栈
s.top();//返回栈顶元素
s.size();//返回元素个数
s.empty();//判空

3.queue：

//队列容器
//只能从队尾插入元素，队首删除元素
queue<int> q;
q.push(1);//入队
q.pop();//出队
q.front();//返回队首元素
q.back();//返回队尾元素
q.size();//返回元素个数
q.empty();//判空

4.priority_queue：

//优先队列容器
//只能从队尾插入元素，队首删除元素
//队列中最大的元素总是位于队首（默认从大到小排序，自己可以自定义比较函数来修改）

priority_queue<int> pq;
pq.push(1);//入队
pq.pop();//出队
pq.top();//返回队首元素
pq.size();//返回元素个数
pq.empty();//判空

//自定义比较函数
元素为结构体：
struct info
{
string name;
float score;
bool operator < (const info &a) const
{
return score>a.score;//从小到大（注意这次的符号）
}
}；

元素非结构体：
struct mycomp
{
bool operator () (const int &a,const int &b) const
{
return a>b;//从小到大（注意这次的符号）
}
};
priority_queue<int,vector<int>,mycomp> pq;//显示说明其内部结构是vector.（注意：当有自定义比较函数时，必须显示说明其内部结构是vector！）

5.deque：

创建
deque<int> d;
deque<int> d(10);//容量为10
deque<int> d(10,8.5);//10个并初始化为8.5

插入：
push_back()尾部插入，扩张队列
push_front()头部插入，不扩张队列，往后挤，把尾部的元素挤出去了
以上两个参数是一个元素对象
insert()中间某位置插入元素，不扩张队列，仍是挤出尾部的元素
参数为两个：迭代器位置+元素对象
eg：d.insert(d.begin()+1,88);//即插入到第二个位置，后面的往后顺延，最后一个丢失

遍历：
d[i]//数组方式

deque<int>::iterator it;
for(it=d.begin();it!=d.end();it++)
{
cout<<*it<<" ";
}//前向迭代器方式

deque<int>::reverse_iterator it;
for(rit=d.rbegin();rit!=d.rend();rit++)
{
cout<<*rit<<" ";
}//反向迭代器方式

删除：
首部：d.pop_front();
尾部：d.pop_back();
中间：d.erase(d.begin()+1);
清空：d.clear();

6.set：

#include <set>
#include <algorithm>

//不会重复插入相同键值的元素
//采用红黑树的平衡二叉检索树结构，中序遍历

set<int> s;

s.insert(3);//默认从小到大

set<int>::iterator it;
for(it=s.begin();it!=s.end();it++)
{
cout<<*it<<"　"；
}

//反向遍历
set<int>::reverse_iterator rit;//反向迭代器
for(rit=s.rbegin();rit!=s.rend();rit++)
{
cout<<*rit<<" ";
}

//元素删除，删除对象可以是某个迭代器位置上的元素、等于某键值的元素、一个区间上的元素
s.erase(s.begin()+1);
s.erase(6);
s.erase(s.begin(),s.begin()+4);
s.clear();

s.size();

s.find(6);//查找键值6，查到了则返回其迭代器位置，否则返回最后一个元素后面的位置，即end()
set<int>::iterator it;
it=s.find(6);
if(it!=s.end())
cout<<*it<<endl;

//自定义比较函数 默认从小到大存储

//非结构体元素
struct comp
{
bool operator () (const int& a,const int& b) const
{
return a>b;//从大到小
}
}
set<int,comp> s;//创建
set<int,comp>::iterator it;
其他操作一样

//结构体元素
struct info
{
string name;
float score;
bool operator < (const info &a) const
{
return score>a.score;//从大到小
}
}
set<info> s;//创建
set<info>::iterator it;

7.multiset：

#include <set>
#include <algorithm>

//允许重复的元素键值插入

//在插入，删除，查找方面与<set>有区别

multiset<string> ms;
ms.insert("abc");
multiset<string>::iterator it;

//erase()可以删除某个迭代器位置的元素，某段区间的元素，键值等于某个值的所有重复元素（并返回删除元素个数）。
ms.erase("123");
ms.clear();

//find()，如果查到，返回该元素第一次出现的迭代器位置，否则返回end()
it=ms.find("123");

8.map：

#include <map>
#include <algorithm>

//不会重复插入相同键值的元素
//采用红黑树的平衡二叉检索树结构，中序遍历
//比较函数只对键值进行比较
//和set使用大都相同

map<string,float> m;
m["jack"]=98.5;//插入元素
m.insert(pair<string,float>("lvhuan",18.5));

map<string,float>::iterator it;
for(it=m.begin();it!=m.end();it++)
{
cout<<(*it).first<<":"<<(*it).second<<endl;//输出键值与映照数据
}

//可以删除某个迭代器位置元素、等于某键值的元素、某迭代器区间的所有元素
m.erase(4);
m.clear();

//反向遍历
map<string,float>::reverse_iterator it;
for(it=m.rbegin();it!=m.rend();it++)
{
cout<<(*it).first<<":"<<(*it).second<<endl;//反向输出键值与映照数据
}

//find()返回键值所处迭代器位置或end()位置

//自定义比较函数（默认从小到大）
非结构体元素
struct comp
{
bool operator () (const int &a,const int &b) const
{
return a>b;//从大到小
}
}
map<int,char,comp> m;
map<int,char,comp>::iterator it;

结构体元素
struct info
{
string name;
float score;
bool operator < (const info &a) const
{
return score>a.score;//从大到小
}
}
map<info,int> m;//创建
map<info,int>::iterator it;
for(it=m.begin();it!=m.end();it++)
{
cout<<(*it).second<<":";
cout<<((*it).first).name<<" "<<((*it).first).score<<endl;
}

9.multimap：

#include <map>
#include <algorithm>

//允许重复插入相同键值的元素

multimap<string,float> m;
m["jack"]=98.5;//插入元素
m.insert(pair<string,float>("lvhuan",18.5));

multimap<string,float>::iterator it;
for(it=m.begin();it!=m.end();it++)
{
cout<<(*it).first<<":"<<(*it).second<<endl;//输出键值与映照数据
}

//erase()可以删除某个迭代器位置的元素，某段区间的元素，键值等于某个值的所有重复元素（并返回删除元素个数），还有清空clear()

//find()，如果查到，返回该元素第一次出现的迭代器位置，否则返回end()
it=m.find("123");

10.list：

//双向循环链表容器

//迭代器只能使用“++”或“--”，不能使用“+n”或“-n”。

创建：
list<int> l;
list<int> l(10);//容量10

插入，都会自动扩张：
尾部：push_back()
首部：push_front()
中间：只能插到迭代器位置处：l.insert(it,20);//元素对象为20

遍历：
list<int>::iterator it;
for(it=l.begin();it!=l.end();it++)
{
cout<<*it<<" ";
}//前向迭代器方式

list<int>::reverse_iterator it;
for(rit=l.rbegin();rit!=l.rend();rit++)
{
cout<<*rit<<" ";
}//反向迭代器方式

删除：remove()删除一个元素值，值相同的元素都会被删除。
l.remove(1);//删除值为1的所有元素

l.pop_front();//删除首部元素
l.pop_back();//删除链表尾部元素

list<int>::iterator it;
for(it=l.begin();it!=l.end();it++)
{
cout<<*it<<" ";
}
it=l.begin();
it++;
it++;
l.erase(it);//删除迭代器位置元素

l.clear();//清空

查找：find()，找到则返回迭代器位置，否则返回end().
eg:it=find(l.begin(),l.end(),5);//查找这个区间上的值为5的元素的位置

升序排序：
l.sort();

删除连续重复元素,只保留一个：
l.unique();//注意是删除连续重复，不是单单重复

11.bitset：

//bit位元素的序列容器，每个元素只占一个bit位，取值0或1.

/*
bitset类
方法列表：
b.any() b中是否存在置为1的二进制位？
b.none() b中不存在置为1的二进制位吗？
b.count() b中置为1的二进制位的个数
b.size() b中二进制位的个数
b[pos] 访问b中在pos处的二进制位
b.test(pos) b中在pos处的二进制位是否为1？
b.set() 把b中所有二进制位都置为1
b.set(pos) 把b中在pos处的二进制位置为1
b.reset() 把b中所有二进制位都置为0
b.reset(pos) 把pos处的二进制位置为0
b.flip() 把b中所有二进制位取反
b.flip(pos) 把pos处的二进制位取反
b.to_ulong() 用b中同样的二进制位返回一个unsigned long值
os<<b 把b中的位集输出到os流
*/

//创建
bitset<100000> b;//创建时必须指定容器大小，且不能再修改大小。默认初始值为0.

//元素赋值
b[6]=1;//下标法，最低位为第0位
b.set();//全部置1
b.set(6);//将指定位置1
b.reset();//全部置0
b.reset(6);//指定位置0

//输出元素
cout<<b[i];//下标法输出，可以借用b.size()来控制个大规模输出
cout<<b;//注意输出的可是二进制形式哦（01串）