STL用法总结

vector

构造

vector<int> a;
vector<int> a(100) ;//初始长为100
vector<int> a(100,1);//长度为100，赋初值为1
vector<vector<int> > a(100,vector<int>());
vector<vector<int> > a(100,vector<int> (100,-1);
vector<int> a[100] {{100,1}}//括号里有省略，这是类似数组的构造

常用函数

     v1.resize(10,5);//改变大小，赋初值5,默认零
	 v1[2]=6;//先resize,才能用,/vector里有值/初始长度
	 v1.push_back(7);//在后面添加
     v1.pop_back();//删除最后一位
     v1.front()//返回第一个
     if(v1==v2) //比较
     if(!v1.empty())//不为空
   	 int n=v1.size();//大小
	 v1.insert(v1.begin()+1,2);//插入
	 v1.erase(v1.begin()+1);//删除第二个
	 v1.erase(v1.begin()+2,v1.begin()+5);//删除第3到5的三个元素
	 v1.clear();//清空所有
	 swap(v1,v2);//交换vector
	 sort(v1.begin(),v1.end());//sort排序
	 v1.erase(unique(v1.begin(),v1.end()),v1.end());//对有序序列去重

遍历

     for(auto it:v1)//加强for遍历
	 cout<<it;
	 for(auto it=v1.begin();it<v1.end();it++)//迭代器遍历
	 cout<<*it;
	 for(int i=0;i<3;i++)//下标遍历
	 cout<<v1[i];

适用情形

1.一般情况下，可以代替数组，除非该题卡常
2.n x m矩阵，比较大时，数组浪费内存，会MLE。用vector可以。另外它的数据存在堆空间，不会爆栈。

注意事项

1.最好提前指定长度。不停push_back，会慢
2.size()返回类型为size_t,一般[0,2^32)
3.能直接比较: ==, !=, <=, >=, <, 和 >.
4.end()前一位 是尾值
5. rbegin(),rend(),是逆迭代器

使用迭代器删除可能会出现的错误

vector<int > a{1,2,3,4};
for(auto it=a.begin();it!=end();it++)
if(*it==2||*it==3)
a.erase(*it);
//遍历结果是{1，3，4}；
//3不会删除

vector<int > a{1,2,3,4};
for(auto it=a.begin();it!=end();it++)
if(*it==4)
a.erase(it);
//会出现re

可以思考一下，这两种错误

Set & MultiSet（不能用sort,会自动排序）

多元集合(MultiSets)和集合(Sets)相像，只不过支持重复对象,其用法与set基本相同。
set 其中所包含的元素的值是唯一的，且是按一定顺序排列的，因为其内部是通过链表的方式来组织，所以在插入的时候比vector 快，但在查找和末尾添加上比vector 慢

构造

     set<int> s1;                       
     set<int> s2{1,2,3};                // 定义 s2，初始值为 {1,2,3}
	 set<int> s3(s2);                   // 使用 s2 初始化 s3
	 set<int> s4(s2.begin(), s2.end()); // 使用迭代器初始化 s4
	 set<int,greater<int> > s5;        //从大到小

常用函数

删除，查找

	  s5.erase(10);//删除所有元素10
	  set<int>::iterator iter2 = s5.begin(), iter1;   // 迭代器删除
	  iter1 = iter2;
	  iter2++;  //不能iter+=2
	  s5.erase(iter1, iter2); // 删除 [iter1, iter2) 区间的元素
	  auto m=s5.find(4);//查找，删除
	  s5.erase(m);	

  		 s2.clear();// 清空容器元素
         s.lower_bound(key);		//返回指向第一个不小于给定键值key的元素的迭代器。
         s.upper_bound(key);		//返回指向第一个大于给定键值key的元素的迭代器。
         auto n=s5.lower_bound(15);  //例子
         if(n==s5.end())     cout<<"****";

遍历

用迭代器
for(set::iterator it=st.begin();it!=st.end();++i)
cout<<*it<<endl;
强化for
for(auto it:st)//不确定
cout<<it<<endl;

unordered_set(不排序集合），unordered_multiset

unordered_set是一个集合容器，它存储唯一的元素，并且元素是无序的。 与set相比，unordered_set的插入、删除和查找操作都更快 。插入，是插前面，不能用lower_bound。不能用sort.

Map & MultiMap

区别

1. 实现不同
   ●unordered_ map底层是用哈希表实现的
   ●map底层是用红黑树实现的
   ●unordered_ map是不按键值排序的，插入的时间是O(logn),查询时间是0(1)
   ●map是按键值排序的,插入的时间是O(logn),查询时间是O(logn)

2. 使用范围不同
   ●unordered_ map的使用比较局限，它的key只能是int、double等基本类型以及string,而不能是自己定义的结构体
   ●map可以支持所有类型的键值对

常见用法

//声明
 map<int,int> m1;
 map<int,int,greater<int> > m2;//从大到小排
 unordered_map<int,int> m3;
 //插入
 m2.insert({2,7});//和上边循环重合就没效果了
 //删除
 m2.erase(3);//删除键3
 auto it=m2.begin();//删除从[it,m2.end)
 it++;
 m2.erase(it,m2.end());
 m2.clear();    //清空
 //查找
 auto n=m2.find(3);
 if(n==m2.end())
 cout<<"****";
 //遍历，要加first,second
 if(!m2.empty())
 for(auto it:m2)
 cout<<it.first;
 //数量
 int m=m2.count(4); cout<<m ;
 //size
 int k=m2.size();

注意事项

不能用迭代器计算下标
访问遍历用迭代器，操作别用
去重函数unique和string能不能用

stack

stack是一种先进后出（LIFO）的数据结构，只能从栈顶进行插入和删除操作，不支持在其他位置访问或修改元素,sort排序。

成员函数

stack<int> a;
a.push(元素）;
a.pop();
a.top();
a.size();
a.empty();

注意事项

1.不可以下标索引
2.只读
3.不可用迭代器计算下标

queue（队列）

queue队列经常在图的广度优先搜索bfs和最短路算法spfa中应用。

queue中的常用函数

queue<int> q;							//
queue<pair<int,int> I> qq;					//声明一个pair类型的队列容器
q.push(5);							//将5插入队尾  
q.pop();								//将队头元素删除  
int x = q.front();						//返回队头元素 
int y = q.back();						//返回队尾元素  

priority_queue（优先队列）

priority_queue<int> q;				//声明大顶堆
priority_queue<int,vector<int>,greater<int> > p;	//声明一个二元组类型的队列

q.push(111);						//将元素插入队列中 O(log n)
q.pop();							//删除队头元素， O(log n)
int f = q.top();                  //返回队列中最大元素，O(1)
int k=p.top();					 //返回队列中最小元素，O(1)

priority_queue不支持删除堆中任意元素。

deque（双端队列）

双端队列deque是一个支持在两端高效插入或删除元素的连续线性储存空间。它像是vector和queue的结合。与vector相比，deque在头部增删元素仅需要O(1)的时间；与queue相比，deque像数组一样支持随机访问。可以sort排序。

常用函数

deque<int> q;							//声明一个int型的deque容器
int y = q.front(), z = q.back();		//返回队头/尾元素
q.push_back(5);							//从队尾入队
q.push_front(7);						//从队头入队
q.pop_front();							//删除队头元素
q.pop_back();							//删除队尾元素
q.clear();								//清空容器 
q.erase(q.begin());						//删除第一个