c++的stl容器

vector动态数组
需要用到头文件#include,支持随机访问，不支持在任意位置进行O(1)操作。
定义方式
vector a;//相当于一个长度动态变化的int数组。
vector b[233]；//相当于第一维长度为233第二维长度动态变化的int数组
struct res{}; vector c; //也可以定义结构体来保存到vector中
vector a={1,2,3,4,5,6,7,8,9,10};//直接定义数据存放到vector中
库函数
size/empty/clear
size返回vector大小，empty判断是否为空，若为空返回1，否则返回0，clear清空数组
cout<<a.size()<<endl;
a.clear();
cout<<a.size()<<endl<<a.empty()<<endl;
迭代器
vector::iterator it;类似指针移动。
begin/end
begin函数返回指向vector中第一个元素的迭代器
end函数返回指向vector中最后一个元素的迭代器
通过迭代器可以遍历整个函数。
vector::iterator it;
for(it=a.begin();it!=a.end();it++){
cout<<*it<<" ";
}
类似于通过size访问，因为vector支持数组下标的随机访问。
for(i=0;i<a.size();i++){
cout<<a[i]<<" ";
}
front/back
front函数返回vector的第一个元素。
back函数返回vector的最后一个元素。
push_back/pop_back()
a.push_back(x)把元素x插入到vector a的尾部
b.pop_back()删除vector a的最后一个元素。
a.push_back(111);
cout<<endl<<a.front()<<" "<<a.back();
a.pop_back();
cout<<" "<<a.back()<<endl;
queue队列
头文件#include主要包括循环队列queue和优先队列priority_queue两个容器。
定义方式
queue q;
struct res{} queue q;
priority_queue q;//大根堆
priority_queue<int,vector,greater>q;//小根堆
priority_queue<pair<int,int>>q;

循环队列queue
push从队尾插入
pop从队头弹出
front返回队头元素
back返回队尾元素
queue q;
for(i=0;i<=10;i++)
q.push(i);
cout<<q.size()<<endl;
q.push(3);
int t=q.size();
for(i=0;i<t;i++){
cout<<q.front()<<" ";
q.pop();
}
优先队列priority_queue
push把元素插入堆
pop删除堆顶元素
top查询堆顶元素
cout<<endl;
priority_queue qs;
for(i=0;i<=10;i++)
qs.push(i);
cout<<qs.size()<<endl;
int ts=qs.size();
qs.push(3);
for(i=0;i<ts;i++){
cout<<qs.top()<<" ";
qs.pop();
}
注：优先队列内元素默认是有序的，从大到小排序，全部弹出之后队列大小都为0，不支持下标随机访问，在使用循环中使用q.size()时，要将它先进行赋值，不然每次弹出队列元素时。相应的队列大小都会进行改变。

stack栈
头文件#include，主要包括栈stack。
定义方式
stack s;
struct res{}; stack s;
库函数
push 向栈顶插入元素
pop 弹出栈顶元素
for(i=0;i<=10;i++)
s.push(i);
s.push(3);
int m=s.size();
cout<<endl;
for(i=0;i<m;i++){
cout<<s.top()<<" ";
s.pop();
}
栈和队列类似，栈是先进后出，队列是先进先出，都不支持数组下标的随机访问。

deque双端队列
支持在两端进行高效插入和删除元素的连续线性存储空间，像vector和queue的结合，与vector相比deque的头部增删元素仅需要O(1)的时间与queue相比，deque可以支持像数组一样的随机访问，需要用到头文件#include
定义方式
deque d;
struct res{}; deque d;
库函数
[ ]根据下标进行随机访问
begin/end 返回deque的头/尾迭代器
front/back 队头/队尾元素
push_back 从队尾入队
push_front 从队头入队
pop_back 从队尾出队
pop_front 从队头出队
clear 清空队列
deque d;
for(i=0;i<=10;i++){
d.push_front(i);//队头插入
d.push_back(i);//队尾插入
}
int n=d.size();//队列大小
for(i=0;i<n;i++)
cout<<d[i]<<" ";//下标随机访问

cout<<endl;

deque<int>::iterator de;
for(de=d.begin();de!=d.end();de++){
	cout<<*de<<" ";
}

cout<<endl;
d.push_front(100);//在头部插入值为100的元素 
cout<<d.front()<<" ";// 队头元素
d.pop_front(); //弹出当前队头元素 
cout<<d.front()<<" ";// 此时的队头元素

cout<<endl;
d.push_back(200);//在头部插入值为两百的元素 
cout<<d.back()<<" ";//队尾元素
d.pop_back();//弹出队尾元素 
cout<<d.back()<<" ";//此时队尾元素 

d.clear();//清空队列
cout<<endl<<d.size();//清空队列后此时队列大小为0

set集合
头文件#include包括set和multiset两个容器，set是有序集合，multiset是有序多重集合，即前者的元素不能重复，后者可以包含若干个相等的元素，set和multiset的内部实现是一颗红黑树。他们支持的函数基本相同。
定义方式
set s;
struct res{};set s;
multiset s;
库函数
size/empty/clear
set ss;//元素不能重复
cout<<ss.size()<<endl;
ss.clear();
cout<<ss.empty()<<endl;
迭代器
set和multiset的迭代器称为双向访问迭代器，不支持随机访问，支持解引用，仅支持++和--两个算术相关操作。
set::iterator it;
it++指向下一个元素it--指向上一个元素
begin/end 返回集合的首尾迭代器，时间复杂度为O(1)
s.insert(x)将一个元素x插入到集合s中，若set中该元素已存在则不会重复进行插入
s.find(x)在集合s中查找等于x的元素，并指向该元素的迭代器。若不存在则返回s.end();
s.lower_bound(x)查找大于等于x的元素中最小的一个并返回该元素的迭代器。
s.upper_bound(x)查找大于x的元素中最小的一个并返回该元素的迭代器。
s.erase(it)从s中删除迭代器it指向的元素时间复杂度为O(logn)，s.erase(x)从s中删除所有等于x的元素。
s.count(x)返回集合中等于x的元素个数。
set ss;//元素不能重复
for(i=0;i<=10;i++){
ss.insert(i);//将元素i插入到集合中时间复杂度为O(logn)
}
ss.insert(11);
ss.insert(12);
ss.insert(13);
set:: iterator se;
cout<<endl;
se=ss.find(6);//查找集合中等于 5的元素并返回该元素的迭代器 如果不存在则指向ss.end()
cout<<se<<endl;
ss.lower_bound(6);//查找集合中大于等于5的元素中最小的一个，并指向该元素的迭代器
cout<<se<<endl;
ss.upper_bound(7);//查找集合中大于5的元素中最小的一个，并指向该元素的迭代器
cout<<se<<endl;

for(se=ss.begin();se!=ss.end();se++){
cout<<*se<<" ";	 
}
cout<<endl; 
int cnt=ss.count(5);//查找ss中所有等于5的元素的个数
cout<<cnt<<endl;

ss.erase(5);//从ss中删除所有等于5的元素
cout<<ss.count(5)<<endl;

ss.erase(se);//从ss中删除迭代器se指向的元素
cout<<*se<<endl;

map容器
map容器是一个键值对key-value的映射，其内部实现一颗以key为关键码的红黑树，map的key和value可以是任意类型，其中key必须定义小于号运算符。
函数定义
map<key_type,value_type) name;
map<int,int>name;
map<pair<int,int>,vector> test;
库函数
size/empty/clear/begin/end均与set类似
insert/erase与set类似，但其参数均是pair<key_type,key_type>
h.find(x)在变量名为h的map中查找key为x的二元祖。
[ ]操作符，h[key] 返回key映射的value的引用。
map<int,int> vis;
vis.insert(pair<int,int>(0,22));
vis.insert(pair<int,int>(1,11));
vis.insert(pair<int,int>(2,33));
vis.insert(pair<int,int>(3,44));

for(i=4;i<10;i++)
vis.insert(pair<int,int>(i,i*11)); 
cout<<vis.size()<<endl;




for(i=0;i<vis.size();i++)
cout<<vis[i]<<" ";
cout<<endl; 
vis.clear();//清除vis内的元素 
cout<<vis.empty();//判断vis是否为空