STL常用模板

常用函数

Sort()

  Sort(start,end,compare); 时间复杂度O(nlog₂n)。

  第三个参数还可以是"less<数据类型>()//从小到大排序", "greater<数据类型>()//从大到小排序"。

Reverse()

  Reverse(start,end);

Unique()

  Unique(start,end,compare);

  功能：去除相邻的重复元素，只保留一个。返回的是去重后容器中不重复序列的最后一个元素的下一个元素。

  注意：它并不真正把重复的元素删除,而是该函数把重复的元素移到后面去了，然后依然保存到了原数组中，然后返回去重后容器中不重复序列的最后一个元素的下一个元素。

Erase()

  Erase(start,end);

  注意Erase()的删除容器时候的陷阱。

for(it = List.begin(); it != List.end();)
{
   if(WillDelete(*it))
       List.erase(it++);//it = List.erase(it);
   else
       it++;
}

Search()

  lower_bound(start, end, target); 查找第一个大于等于target目标值的位置。

  upper_bound(start, end, target); 查找第一个大于target目标值的位置。

  binary_search(start, end, target); 查找target是否存在于数组或vector中，找到返回true，否则返回false。

  s.find(t); 在s中查找t。

String To Int

  stoi(s); 将字符串s转化成整形，s为string类型，即string --> int

  atoi(s); 将字符串转化为整形，但s为const char类型，可以先用s.c_str()方法把string类型转化为const char类型，再转为整形，即const char --> int

  stringstream; 需要头文件#include,可将只含数字的字符串转化为整形，也可将数字和小数点组成的字符串转化为浮点型，即string --> int, string --> double

Int To String

  stringstream; 需要头文件#include，可将整形或浮点型数字转化为字符串，即int --> string, double --> string

  to_string(); 可将整形转化为字符串，不推荐将浮点型转化为字符串

数组-Vector

//下标访问
for(int i = 0;i<5;i++){
    cout<<v2[i]<<" ";
}

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

//一维vertor的初始化
vector<int> v;
vector<int> v1(v);
vector<int> v2 = {1,2,3,4,5};
    
//二维vertor的初始化
vector<vector<int>> v3;

//常用函数
v.capacity();  //容器容量
v.size();      //容器大小
v.at(int idx); //用法和[]运算符相同
v.push_back(); //尾部插入
v.pop_back();  //尾部删除
v.front();     //获取头部元素
v.back();      //获取尾部元素
v.begin();     //头元素的迭代器
v.end();       //尾部元素的迭代器
v.insert(pos,elem); //pos是vector的插入元素的位置
v.insert(pos, n, elem) //在位置pos上插入n个元素elem
v.insert(pos, begin, end);
v.erase(pos);   //移除pos位置上的元素，返回下一个数据的位置
v.erase(begin, end); //移除[begin, end)区间的数据，返回下一个元素的位置

栈-Stack

//初始化
stack<int> s;
     
//常用函数
s.push();
s.pop();
s.top(); //返回栈顶元素
s.empty(); //栈堆判空
s.size();

链表-List

//初始化
list<int> a{1,2,3};
list<int> a(n); //声明n个元素的链表，每个元素都是0
list<int> a(n,m) //声明n个元素的链表，每个元素都是m
list<int> a(first,last) //用另外一个链表的区间给a赋值，first和last为迭代器
a.assign(n,m); //将a中所有元素替换成n个m

//常用函数
//返回头尾部元素
a.back();
a.front();

//插入元素
a.push_back(12); //在尾部插入一个元素
a.push_front(2); //在头部插入一个元素

//指定位置插入元素
a.insert(it,100); 
a.insert(it,2,100); //在it位置插入俩个元素
a.insert(it,first,last); //first和last为另外一个链表的迭代器 ，在it插入一个元素区间
 
//删除元素
a.pop_back();
a.pop_front();
a.erase(it);
a.erase(a.begin(),a.end());
 
//特殊用法
a.chear();//清空链表
swap(a,b);//交换俩个链表
a.swap(b);
reverse(a.begin(),a.end()); //逆置a链表
a.remove(n); //删除链表中所有n元素

队列-Queue

//初始化
queue<int> q;
queue<int> q[20]; //规定队列元素数量
queue<int,list<int>> q1; //list<int>可以省略
queue<int,list<int>> q2(q1);
//复制构造函数(queue(const queue&))，用一个queue对象创建新的queue对象。 
//利用queue对象q1，创建一个以双向链表为底层容器的queue对象q2

//常用函数
q.push(x);  //入队，将元素 x 从队尾插入（尾插法）
q.pop();    //出队，删除对首元素，并返回其值
q.size();   //返回队中元素个数
q.front();  //返回对首元素
q.back();   //返回队尾元素
q.empty();  //判断是否为空（空返回 1，非空返回 0

/*
优先队列(priority_queue)是一种会按照默认或自定义的优先级进行自动排序的队列，其特点是优先级高的元素排在队首，低的排在队尾。头文件#include< queue > 中提供了两种可直接引用的优先规则（排序规则）：greater、less；其中，less是默认优先规则，表示数字大的优先级大（字符型用ASCLL码比较），放在队首；greater表示数字小的优先级大，放在队首。
*/
//优先队列
priority_queue<int> pq; //默认声明
priority_queue<int,vector<int>,less<int>> pq;
priority_queue<int,vector<int>,greater<int>> pq;

集合-Set

//初始化
set<int> s;

//常用函数
s.insert(key); //插入元素
s.insetr(first，second);
 
s.count(); //用来查找set中某个键值出现的次数 但是一个键值只能在set出现0和1次这样就变成了判断但某个值是否出现set中
 
s.erase(iterator); //删除迭代器指向的值
s.erase(first,second); //删除迭代器first和second之间的值
s.erase(key_value); //删除键值key——value
 
s.find(key); //返回迭代器的值，没有找到返回end()
 
s.lower_bound(key); 返回第一个大于等于key的迭代器
s.upper_bound(key); 返回最后一个大于等于key的迭代器
 
s.clear(); //删除set容器中的所有的元素
 
s.empty(); //判断set容器是否为空
 
s.max_size(); //返回set容器可能包含的元素最大个数
 
s.size(); //返回当前set容器中的元素个数
 
s.rbegin(); //返回的值和end()相同
 
s.rend(); //返回的值和begin()相同

映射-Map

//初始化
map<key,value> name;
map<int,string> ma; //整形到字符串的映射

//常用函数
//插入
m.insert(pair<int,string>(000,"student_zero");
m.insert(map<int,string>::value_type(001,"student_one"));
m[123] = "student_first";
m[456] = "student_second";

m.find(key); //查找

//删除与清空元素
m.erase(key);
m.erase(m.begin(),m.end());

m.size(); //大小