C++STL标准模板库

vector

include <vector>
vector<int> v; 
vector<int> v（n,0）;   //初始化一维数组
vector<vector<int>> array（n,vector<int>（n,0））;  //初始化二维数组

v.push_back(t)   //在容器V的尾端添加一个值为t的元素
v.pop_back()   //去掉最后一个数据
v.front()    //返回第一个元素（容器头部元素）
v.back()    //返回最后一个元素（容器尾部元素）
v.begin()    //返回容器头部指针，迭代器接收
v.end()    //返回容器最后一个单元+1的指针，迭代器接收
v.clear()    //清除容器所有数据
v.erase(pos)   //删除pos位置的数据，pos表示迭代器
v.erase(beg, end)  //删除beg--end区间的数据
v.empty()    //判断容器是否为空
v.size()    //查询容器中的数据个数
v.insert(pos, data)  //容器的pos位置插入data数据

array.size()    //二维数组的行数
array[0].size()    //二维数组的列数

stack

#include <stack> //栈
stack<int> stk;    //栈

stk.empty()    //判断栈是否为空，若空返回true，非空返回false
stk.pop()     //删除栈顶元素
stk.top()     //取出栈顶元素
stk.push()    //向栈中插入元素
stk.size()     //栈的数据个数

queue

#include <queue> 
queue<int> que;    

que.push()   //入队（先进先出）
que.front()   //获得队首元素
que.back()   //获得队尾元素
que.pop()   //出队
que.empty()   //“空”判断
que.size()   //队列元素个数

deque

#include <deque> 
deque<int> deq; 

deq.push_front();
deq.push_back();
deq.pop_front();
deq.pop_back();
deq.insert(c1.begin()+3, 10); //在第3个成员后插入10
deq.erase(c1.begin()+3);  //擦除第3个成员 
deq.clear();

priority_queue

#include<queue>
 //升序队列，小顶堆
 priority_queue <int,vector<int>,greater<int> > q;
 //降序队列，大顶堆
 priority_queue <int,vector<int>,less<int> >q;
 
top 访问队头元素
empty 队列是否为空
size 返回队列内元素个数
push 插入元素到队尾 (并排序)
emplace 原地构造一个元素并插入队列
pop 弹出队头元素
swap 交换内容

string

string s;
to_string(int m)   //int型转化为string类型
substr(int m, int n) //复制子字符串，m表示起始位置，n表示长度
char* strstr(char* str1,char* str2)  //strstr(str1,str2) 函数用于判断字符串str2是否是str1的子串。
                                 //如果是，则该函数返回str2在str1中首次出现的地址；否则，返回NULL。
s.find(‘i’);           //从头寻找I;返回下表
s.rfing(‘i’);            //从尾寻找
s.find(“str”);         //从头寻找字符串，返回第一个字母下标
s.sfind(“str”);        //从尾寻找字符串，返回第一个字母下标

isdigit是计算机C(C++)语言中的一个函数，主要用于检查其参数是否为十进制数字字符。
isdigit(‘1’) = true;

迭代器iterator

#include<iterator>
vector<int>::iterator it;  //创建一个迭代器（指针）

堆（Heap）

最大堆：父节点必定比子节点不小，最大值在堆顶（树的根节点）

最小堆：父节点必定比子节点不大，最小值在堆顶（树的根节点）

priority_queue<int,vector,greater > S; //优先队列实现最小堆

make_heap(nums.begin(),nums.end(),greater()); //STL创建最小堆 /less() 大堆

void push_heap(b,e,cmp=greater() ) //堆插入
向堆中插入元素分为两个步骤：
（1）先将待插入的元素插入到底层容器的末端，通过push_back函数实现。
（2）再调用push_heap(b,e,cmp)函数堆新插入的元素做向上调整

void pop_heap(b,e,cmp=greater() ) //堆删除
要实现堆的真正删除操作，分两步进行：
（1）先调用pop_heap函数将首部的元素与尾部元素交换，再将原尾部的元素做向下调整操作。此时，原堆顶元素被放置在最后一个位置，并未从底层容器中删除。
（2）若要实现真正的元素删除，可以调用底层容器的pop_back函数。

inline void sort_heap(b,e,cmp=greater() ) //堆排序

map类（关联式容器）

map<int, int> tem; //第一个int表示key值类型，第二个int表示存储对象类型

for (int i = 0; i < len; i++)

{

tem[data[i]]++; //data[i]表示key值，data[i]键值对应的存储对象自++

}

/将string型映射到set：使得string映射到int一对多/

map<string, set > mp;
map<string, vector > mp;

/遍历map/

map<int, int> hm;

hm[1] = 4;

hm[2] = 5;

hm[3] = 6;

auto it = hm.begin(); //it->first表示key，it->second表示value

while (it != hm.end())
{
cout << it->first << it->second << endl;
it++;
}

一般寻找链表、数组等中重复出现的“值”时，都能用map（或hashtable）计数实现。

map：内部实现红黑树，因此元素是有序的，运行效率非常高，但是空间占用率高，适用于有顺序要求的问题。

unordered_map：内部实现hash表，因此查找速度非常快，但是哈希表建立比较消耗时间，适用于查找问题。

map<pair<int, int>, int> m;
pair<int, int> xy; //pair将两个数+据合并成一组数据
tuple<int, int,int> xyz // tuple将三个数+据合并成一组数据
cin>>xy.first>>xy.second; //pair对象赋值
cin>> xyz.first>> xyz.second>> xyz.third; //tuple对象赋值

或：int a=0, b=0;
xy=make_pair(a, b);
或：pair<int, int> xy(0, 0);

哈希集

#include <unordered_set>

unordered_set<int> hashset // 创建int型的哈希集
hashset.insert(1)    //在哈希集hashset中插入键值为“1”的数据
hashset.erase(2)    //删除值为“2”的数据
hashset.count(2)    //值为2的数据是否存在，存在则大于0
hashset.size()       //大小
hashset.clear()      //清空哈希集
hashset.empty()     //是否为空
hashset.find（1）   //得到相应位置的迭代器

哈希映射

#include<unordered_map>

unordered_map<int, int> hashmap;   //创建键值和值为int的哈希映射
hashmap.insert(make_pair(2, 3));      //insert a new (key, value) pair
hashmap[1] = 2;      //insert a new (key, value) pair or update the value of existed key
hashmap.erase(2);     //delete a key
hashmap.count(2) <= 0    //check if a key is in the hash map
    // 8. iterate the hash map
    for (auto it = hashmap.begin(); it != hashmap.end(); ++it) {
        cout << "(" << it->first << "," << it->second << ") ";
    }
hashmap.clear();   //clear the hash map
hashmap.empty()  // check if the hash map is empty

sort

#include<algorithm> 

   vector<int> v;
   sort(v.begin(), v.end(), [](int &a,int &b){return a<b;}); //生序
  
   vector<string> words;
   sort(words.begin(),words.end(),[](string &a,string &b){return a.size()<b.size();});//长度生序