C++ STL 算法竞赛常用模板归纳汇总
向量vector(相当于可变长数组）
/*STL库
vector、deque、list、set、
map、multiset、multimap、unordered_set、
unordered_map、unordered_multiset、unordered_multimap、
stack、queue、priority_queue、string、pair*/
#include
#include
using namespace std;
int main(){
//vector
//定义：vector<数据类型> 名称 (元素个数，[初值])
vector vec; //创建一个长度为 0的初始数组
vector vec2(100,1); //创建一个元素个数为100，初值为1的初始数组
//创建一个名为arr2的二维数组，这个数组有5行，4列，初值为 1
//相当于[ [1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1] ]
vector< vector > arr( 5, vector (4,1) ) ;
//创建一个名为arr3的三维数组，这个数组为5*6*4,初值是0
vector< vector< vector > > arr3( 5 , vector< vector > ( 6,vector(4,0) ) );
//为vector数组 vec增加元素7,13（在末尾加上）
vec.push_back(7); //在末尾放上7
vec.push_back(13); //在末尾放上13
//删除vector数组的元素7（删除末尾的）
vec.pop_back();
//快速清空vector数组
vec.clear();
//判断数组vec是否为空
vec.empty(); //它返回的是一个布尔型变量
//重新设置数组vec大小,将其设为5，补充的初值为3,则vec变为[7,3,3,3,3],如果不设置初值,新增空间默认补 0
vec.resize(5,3) ;
vec.resize(3); //如果新设置的大小比原来的小，那么会把原数组最后的几个元素删除，vec变为[7,3,3]
//获取此时vector数组的大小
vec.size();
return 0;
}
PS：vector数组的动态长度机制是这样的，加入我首先开了一个长度为10的vector数组，当这个数组存储的元素数目大于10的时候，vector会自动开一个大小为当前vector大小的2倍的新数组vector2，并将vector的数据全部复制到vector2中去（如果再超出限度就再开一个大小是vector2的2倍的新数组vector3，以此类推……）
stack:栈
/*STL库
vector、deque、list、set、
map、multiset、multimap、unordered_set、
unordered_map、unordered_multiset、unordered_multimap、
stack、queue、priority_queue、string、pair*/
#include
#include
using namespace std;
int main(){
//stack:栈，先进后出
//定义：stack<数据类型> 名称
stack stk;
//进栈：
stk.push(1.2);
stk.push(1.5);
stk.push(3.3);
//出栈 ：
stk.pop() ;
//查看栈顶元素
stk.top() ;
//查看栈的元素个数
stk.size();
//判断栈是否为空
stk.empty();
// 注：vector也可以当栈使用
vector vec;
//进栈：
vec.push_back(1.2);
vec.push_back(1.5);
vec.push_back(3.3);
//出栈：
vec.pop_back()
return 0;
}
Pair元组
#include
using namespace std;
int main(){
pair p ={1,2}; //定义二元组
pair,int> m ;//定义三元组
//cout< > vec={{1,2},{3,4},{5,6}};
for(int x=0;x queue，priority_queue：队列与优先队列（本质是堆）
#include
#include
#include
using namespace std;
int main(){
//queue：队列
queue zhang; //声明队列
//进队:
zhang.push(1);
zhang.push(2);
zhang.push(3);
//查看队首，队尾:
zhang.front() ;
zhang.back();
//出队：
zhang.pop();
zhang.pop();
//查看队列大小:
zhang.size();
//判空：
zhang.empty();
//priority_queue:优先队列（本质是堆）
priority_queue zhangyu; //默认是一个大顶堆
//进堆
zhangyu.push(1);
zhangyu.push(3);
zhangyu.push(10);
zhangyu.push(7);
//查看堆顶（大顶堆的堆顶元素是整个堆的最大值）
zhangyu.top();
//出堆（把堆顶元素弹出）
zhangyu1.pop();
//创建一个小顶堆，第一个参数是堆的数据类型，第二个参数是堆的底层存储结构(默认是vector) ,第三个参数是一个反函数
priority_queue< double, vector ,greater > sen;
sen.push(1);
sen.push(3);
sen.push(5);
sen.push(9);
sen.top(); //结果会是1，小顶堆的堆顶元素是整个堆中最小的值
//修改堆顶元素 ，将堆顶元素+1
int x=sen.top();
sen.pop();
sen.push(x+1) ;
} deque：双端队列（速度较慢，竞赛中慎用）
#include
using namespace std;
int main(){
deque de={1,3,7,5,9}; //deque双端队列
de.size();//查看队列的元素个数
de.empty();//判空
de.clear();//清空
de.front();//查看队列的第一个元素
de.back();//查看队列的最后一个元素
de.push_back(334);//从队尾插入元素
de.push_back(1231);
de.push_front(7979);//从队首插入元素
de.push_front(9999);
for (auto x:de){
cout< string:字符串
#include
using namespace std;
int main(){
string yusen;
cin>>yusen;//输入字符串
cout< map:映射（类似于字典）
#include
#include
using namespace std;
//映射map：类似于python中的字典
//构建一个键是string类型，值是int类型的映射a
map a; //map<键的类型，值的类型> 名称；
//map的键只能出现一次，并且它的"键是按照升序排序"的
int main(){
map mp;
mp[2];//当访问mp中的一个不存在的元素时，mp会自动为 mp[2]赋上一个初值0
mp[2]=5;//存储元素
mp.erase(2);//删除键为2的元素
//使用find函数查找map中的键 ,find如果查到，就会返回这个键的迭代器，查不到就返回尾迭代器
if(mp.find(2)!=mp.end()) {
printf("yes");
}
//判断键是否存在
mp.count(2); //查找键为2的元素个数
mp.clear();//清空map
mp.empty();///判空
mp[3]=2;
mp[6]=6;
mp[1]=9;
mp[13]=901;
//迭代器遍历map,first是键值对的键，second是键值对的值
for(auto &i:mp){
cout<::itrator it=mp.begin(); it!=mp.end() ;it++){
cout<first<<' '<second< set：集合
#include
#include
using namespace std;
/*
要素 set multiset unordered_set
互异性 是 否(一个元素可出现任意次) 是
无序性 否（元素被从小到大排序） 否（从小到大） 是
应用：
1.因为集合set满足互异性，所以可以用它来去重
2.因为集合set可以把内部元素排序，所以可以用它来排序
*/
int main(){
set zhang; //声明集合
// 清空集合
zhang.clear();
//插入元素
zhang.insert(3);
zhang.insert(4);
zhang.insert(17);
zhang.insert(12);
//删除元素 17
zhang.erase(17) ;
//查找元素
/*count这个函数会返回元素 12在集合中的出现次数 ，因为set集合是元素互异的
所以如果12存在就会返回 0，否则返回 1 */
zhang.count(12) ;
//查看集合大小
zhang.size();
// 集合判空
zhang.empty();
//迭代器
/*
下面的代码首先声明了一个名为 yusen的set类型迭代器，它的初值是zhang.begin(),
这个是zhang的初始位置迭代器，如果yusen没有走到zhang.end(),
也就是末尾迭代器，yusen就自加 1，迭代器的本质是一个对象，初学者可以理解为地址
*/
for(set::iterator yusen=zhang.begin(); yusen!=zhang.end(); yusen++){
cout<<*yusen< 迭代器与常用便捷算法
//STL便捷算法
#include
using namespace std;
//需要用到哪个就把哪部分注释取消即可
int main(){
/*
//swap交换函数
string a="zhang",b="yusen";
cout< zhang={1,3,2,1,32} ;
//默认升序排序
sort(zhang.begin(),zhang.end());
for(vector::iterator yu=zhang.begin(); yu!=zhang.end(); yu++){
cout<<*yu<());
for(vector::iterator yu=zhang.begin(); yu!=zhang.end(); yu++){
cout<<*yu<());//数组降序排序
for(int i=0;i<8;i++){
printf("%d ",sa[i]);
}
*/
/*
//二分查找：现有升序数组[1,1,2,3,3,6,6,7,7,8,29]
//lower_bound():寻找升序序列中大于等于x的第一个元素的位置
//upper_bound():寻找升序序列中大于x的第一个元素的位置
vector arr={0,1,1,8,9,9};
int pos=lower_bound(arr.begin(),arr.end(),8) - arr.begin();
//lower_bound()返回的是元素8位置的迭代器， 减去arr.begin(),可以得到8在数组中的下标
*/
/*
//反转序列
printf("\n\n\n") ;
vector arr2={0,1,2,3,4,5,6,7,8,9};
reverse(arr2.begin(),arr2.end());//将序列全部反转
//reverse(1,4);//将序列下标为1-3的子序列反转，左闭右开的区间
//arr.begin()是指向序列第0个元素的迭代器
//arr.end()是指向序列末尾元素的下一个元素的迭代器
for(auto i:arr2){
cout< arr={1,2,1,4,5,4,4};
//unique只能对有顺序的数组去重，所以要先排序
sort(arr.begin(),arr.end());
//此时arr={1，1，2，4，4，4，5}
auto l=unique(arr.begin(),arr.end()) ;
//此时arr={1，2，4，5，*，*，*} unique会返回第一个*的迭代器，*表示混乱但存在的数据
arr.erase( l , arr.end() ); //把m到arr.end()之间的所有元素全部清除
for(auto ele:arr){
cout< //迭代器：用来遍历无法用下标来表示元素的数据结构 ，比如树，图
#include
#include
using namespace std;
int main(){
set yusen;
yusen.insert(5);
yusen.insert(3);
yusen.insert(89);
for(set::iterator zhang=yusen.begin(); zhang!=yusen.end(); zhang++){
cout<<*zhang<<" "< 