几乎通用的函数

C++STL常用操作之prev、next篇
prev：反向
next：正向
用prev和next可以得到某个迭代器的前一个迭代器或者后一个迭代器的位置，打上*即可得到具体数值

一、vector向量容器

vector<int> v;
1.插入元素操作：.push_back(),.insert()。
    v.push_back(10);//在容器尾部插入一个元素
    v.insert(v.begin(),5);//在传入迭代器的前一个位置处插入一个值
2.向量容器的大小：.size(),.empty()。
    v.size();
    v.empty();
3.首尾元素所在迭代器的位置：.begin(),.end()。
    vector<int>::iterator it = v.begin();
    auto it = v.begin();
4.访问元素：下标访问元素，迭代器访问元素。
    v[1];
    auto it = v.begin();cout<<*it;it++;
5.删除元素：.erase(),.clear()。
    v.erase(v.begin());//删除容器第一个元素
    v.erase(v.begin(),v.end());//删除容器一段区间的元素
    v.clear();//将容器内元素清空
    v.pop_back();//删除容器最后一个元素
6.将容器内元素反向排列(注意是排列，而不是排序)：reverse()。
    reverse(v.begin(),v.end());
7.对容器内元素排序：sort()
    sort(v.begin(),v.end(),cmp);//不写",cmp"时默认元素从小到大排序，cmp可自定义。

二、string字符序列容器

string s;
1.从string对象尾部添加字符：'+'。
    s += "chenqing";
2.在字符串指定位置前插入(字符串下标从0开始)：.insert()。
    s.insert(5, str); // 在s的下标为5的前面插入str这个串
3.访问某个元素：下标访问。
    s[0];
4.删除字符串中的元素：赋空字符串、.erase()。
    s = "";
    s.erase(s.begin());
    s.erase(s.begin(), s.end());//删除区间左闭右开
    s.erase(s.being(), s.begin() + 10);//从s.begin()位置开始，往后删10个元素
5.返回长度：.length()、.size()、.empty()。
    s.length();
    s.size();
    s.empty();
6.替换字符串对象中的一段字符(来替换的可以是字符\字符串)：.replace(startIndex,replacedLength,replaceString)。
    s.replace(0,3,"abc");//必须是""。
7.查找子串：.find(goalString)。
    s.find("chen");//找到则返回子串的第一个元素下标，反之则返回一个远大于被查找字符串长度的数值。
8.获得原字符串的一段子串：.substr(startIndex,goalLength)。
    s.substr(0,5);
    //若填入的goalLength大于s.size()-startIndex,则返回的字符串为startIndex至字符串末位的子串。
9.字符串比较：'='、'>'、'<'。
    string("abcd")>string("bcda");
10.反向排列string对象：reverse()。
    reverse(s.begin(),s.end());
11.作为其他容器的参数：
    vector<string> v;
    map<string,int> m;
12.字符串输入流：stringstream()。
    s = "1 2 3 4";
    int a;
    stringstream scin(s);
    while(scin>>a) 
        cout<<a<<" ";
13.由char[]转为string类型：
    char op[5] = "1234";
    string s(op);// 这样在不使用cin和cout的情况下也能获取string类型的值，只不过要记得转换下。
14.将string类型转为char[]:
    printf("%s", (s).c_str());

三、set集合容器

基于红黑树，会默认从小到大排序。
插入键值后，各迭代器位置上的键值将不可再进行修改。
set本身作用是为了快速检索。
set<int> s;
1.元素插入：.insert()。
    s.insert(5);
2.反向遍历：.rbegin()、.rend()。
    for(auto it = s.rbegin();it != s.rend();it++)
        cout<<*it<<" ";
3.删除元素：.erase()。
    s.erase(1);
    s.erase(s.begin());
    s.erase(s.begin(),s.end());//左闭右开，s.end()其实并没有键值
    s.clear();
4.集合大小：.size()。
    s.size();
5.查找某一个键值是否存在：.find()
    若未找到则返回s.end()
    s.find(5);
6.自定义比较函数：
    set<int,greater<int>> s;//默认是从小到大，添加参数后键值将由大到小排序
    对于结构体类型可按照如下操作：
    const int N = 10;
    struct Node{
        int id,score;
        bool operator<(const Node &a) const
        {
            return a.score<score;//按照该变量从大到小排列。
            //若想从小到大排列则使用">"即可。 
        }
    }p[N];

    int main()
    {
        set<Node> s;
        for(int i=0;i<N;i++)
        {
            p[i] = {i,N-i};
            s.insert(p[i]);
        }
        cout<<s.size()<<endl;
        for(auto t:s)
        {
            cout<<t.id<<" "<<t.score<<endl;
        }
    }

四、multiset多重集合容器

允许重复键值存在。
multiset<int> ms;
1.元素的删除：.erase(),.clear();
    ms.insert(1);
    ms.insert(1);
    ms.erase(1);//会将与该值相同的所有键值都删掉
    ms.erase(ms.begin());
    ms.erase(ms.begin(),ms.end());
    ms.clear();
2.元素的查找：.find()
    ms.find(1);//返回等于该值的所有迭代器中的第一个迭代器。
3.二分查找：.lower_bound(), .upper_bound()
    ms.lower_bound(2);
    ms.upper_bound(2); // 返回等于该值的所有迭代器中的第一个迭代器位置信息。
4.集合大小：.size().
    ms.size();
5.获得集合的最大值：
    *ms.rbegin(); // 反方向的第一个迭代器

五、map映照容器

每一个键值对应一个映照数据，并且该映照数据可以修改。
map<datatype1,datatyp2> m;//datatype1 -> 键值的数据类型 datatype2 -> 键值映照数据的数据类型。
按照datatype1的大小进行排序，默认是从小到大排序。
1.元素插入：同数组赋值一般，插入一个pair<datatype1,datatype2>。
    m["abc"] = 1;
    m["abc"] ++;
    m.insert({"acz",5});
2.元素删除：.erase(),.clear()。
    m.erase("abc");//参数传入的是键值。
    m.erase(m.begin());
    m.erase(m.begin(),m.end());
    m.clear();
3.反向遍历：.rbegin(),.rend();
    for(auto it = m.rbegin();it != m.rend();it++)
        cout<<(*it).first<<" "<<(*it).second;
4.元素的搜索：.find()。
    m.find("abc");//参数传入的是键值。
5.自定义比较函数：
    struct Node{
        int a,b;
        bool operator < (const Node &t) const
        {
            return t.a<a;//按照该变量从大到小的排序。 
        }
    };

    int main()
    {
        map<Node,int> m;
        m.insert({{1,3},1});
        m.insert({{5,6},2});
        for(auto it = m.begin();it != m.end();it++)
            cout<<(*it).first.a<<endl;
    }
6.容器的大小：.size()。
    m.size();

六、multimap多重映照容器

允许重复键值存在。

七、list双向链表

每个节点有三个域：前驱元素指针域、数据域、后继元素指针域。
由于节点不在连续的一段内存，故仅能使用++、--移动迭代器，+n或-n不可以。
list<int> l;
1.元素的插入：.push_back(),.push_front(),.insert()。
    l.push_back(1);//链表尾部插入一个元素
    l.push_front(2);//链表头部插入一个元素
    l.insert(l.begin(),5);//第一个节点之前插入一个元素
2.反向遍历：.rbegin(),rend()。
3.元素的删除：.remove(),.pop_back(),.pop_front(),.erase(),.clear()。
    l.remove(1);//将数据域相同的元素全部删掉
    l.pop_back();//将链表尾部元素删掉
    l.pop_front();//将链表头部元素删掉
    l.erase(l.begin());//仅能放迭代器
    l.erase();
4.元素的查找：find()。
    find(l.begin(),l.end(),5);//从链表的头部到尾部查找5是否存在，如果不存在返回l.end();
5.元素的排序：.sort()。
    l.sort();//可以自定义比较函数
6.剔除连续重复的元素(注意一定是当相邻两个元素的数据域相同时才起剔除作用)：.unique()。
    l.unique();

八、stack栈

具有先进后出，后进先出的特性。
stack<int> s;
1.入栈：.push()。
    s.push(45);
    s.push(20);
2.返回栈顶元素：.top()。
    s.top();
3.出栈：.pop()。
    s.pop();
4.栈的大小：.size(),.empty()。
    s.size();
    s.empty();

九、queue队列

具有先进先出，后进后出的特性。
queue<int> q;
1.入队：.push()。
    q.push(5);
2.出队：.pop()。
    q.pop();
3.队列大小：.size(),.empty()。
    q.size();
    q.empty();
4.队首元素：.front()。
    q.front();
5.队尾元素：.back()。
    q.back();

十、priority_queue优先队列

对应的数据结构为堆。
默认是大根堆，即出队时是将该队列中最大的元素出队。
priority_queue<int> pq;
1.自定义比较函数：
    将大根堆变为小根堆:
        priority_queue<int,vector<int>,greater<int>> pq;
    元素为结构体类型：
    struct Node{
        int a,b;
        bool operator < (const Node &t) const
        {
            return t.a>a;//按照该变量从小到大的排序。 
        }
    };

    int main()
    {
        priority_queue<Node> pq;
        pq.push({1,23});
        pq.push({2,56});
        cout<<pq.top().b;
        pq.pop();
        cout<<pq.top().b;
    }
2.入队：.push()。
    pq.push(5);
3.出队：.pop()。
    pq.pop();
4.返回队首元素：.top()。
    pq.top();
5.返回队列大小：.size(),.empty()。
    pq.size();
    pq.empty();

十一、make_heap 堆

对容器内元素进行排序，使其生成堆。
vector<int> v;
for(int i=0;i<10;i++)
{
    int t;
    cin>>t;
    v.push_back(t);
    make_heap(v.begin(),v.end(),greater<int>())//生成小根堆
}
此时容器v即为小根堆，若想要大根堆则less<int>()或不添加第三个位置的参数

十二、deque 双端队列

双端队列是在队列的基础上的扩展，队列仅能将后来元素插入队头，而双端队列能选择性的在队头或队尾插入、删除元素。
deque<int> dq;
1.尾部插入元素。
    dq.push_back(1);
2.尾部删除元素。
    dq.pop_back();
3.头部插入元素。
    dq.push_fron(1);
4.尾部删除元素。
    dq.pop_front();
5.清空deque对象。
    dq.clear();

十三、bitset位集合容器

bitset容器是一个bit位元素的序列容器，每个元素只占一个bit位，取值位0或1
bitset<the size of goal container> f;
bitset<1000> f;//该声明是指容器f具有1000个元素，即1000个bit位，此时所有元素的值都为0
1.设置元素值：采用下标法，采用set()方法，采用set(pos)方法，采用reset(pos)。
    f[100] = 1;
    f.set(); //一次性将元素设置为1
    f.set(5,1); //将第五位元素设置位1（下标是从0开始）
    f.reset(5); //将第五位元素设置位0
2.输出元素：采用下标法输出，直接向输出流输出全部元素。
    cout<<f[0]<<endl;
    cout<<f<<endl;
3.返回容器大小(对于该容器是指二进制中的位数)：.size()
    cout<<f.size();
4.容器中置为1的二进制位个数
    cout<<f.count();
5.查看容器中第i个位置是否是1,若是1则返回true
    f.test(i);