【C/C++】STL快速使用查询+简单解释用法（更）

前言：用于方便大家有语法遗忘的查询，第一次学习STL的快速算法刷题入门。（无先后顺序，不适合深入学习） 

1.vector(向量)

1.1构造与访问

vector<int>name;//定义，int可以换为任何基本类型，甚至是STL
vector<vector<int>>name;//类似二维数组，这种写法一维长度已经固定了
vector<int>arrayname[arraysize];//每一个arrayname[0]都是一个容器

//访问
//1.使用迭代器vector<int>::iterator it;
vector<int>v;
for(vector<int>::iterator it = v.begin();it!=v.end();it++){
    printf("%d",*it);
}

2.用数组方式访问//在此不举例了

1.2常用函数

vector<int>v;

1.push_back(x):在vector后面插入一个元素
2.pop_back():删除尾部元素
3.size():获取vector中元素个数，并返回(返回的是unsigned类型)
4.clear():清空容器中所有元素，时间复杂度O(n)
5.insert(it,x):用来向vector的任意迭代器it处插入一个元素x，时间复杂度O(n)
        //举例
        #include<stdio.h>
        #include<vector>
        using namespace std;
        int main(){
            vector<int>v;
            for(int i=1;i<=5;i++){
                v.push_back(i);//1 2 3 4 5    
            }
            v.insert(v.begin()+2;-1);//v.begin()指向v[0]
            for(int i=0;i<v.size();i++){
            printf("%d",v[i]);//1 2 -1 3 4 5
            }
            return 0;
        }
6.erase()://两种用法
          (1)删除单个元素
            int main(){
                vector<int>v;
                for(int i=1;i<=5;i++){
                    v.push_back(i);//1 2 3 4 5    
                }
                v.erase(v.begin()+3);//删除的是4
                for(int i=0;i<v.size();i++){
                    printf("%d",v[i]);//1 2 3 5
                }
                return 0;
            }
            (2)删除区间//erase(first,last)删除的是左闭右开区间[first,last)
            int main(){
                vector<int>v;
                for(int i=1;i<=5;i++){
                    v.push_back(i);//1 2 3 4 5    
                }
                v.erase(v.begin()+1,v.begin()+4);//删除的是2,3,4
                for(int i=0;i<v.size();i++){
                    printf("%d",v[i]);//1 5
                }
                return 0;
            }

7. vec.resize(5);  // 调整大小为 5，新添加的元素默认为 0 

2.set(集合)

注：set是一个内部自动有序且不含重复元素的容器

2.1构造与访问

注：set只能通过迭代器访问

//构造
set<int>name;//同vector一样，int可换为其他基本类型
set<int>arrayname[arraysize];//每个array[0]都是一个容器


//只能通过迭代器访问：set<int>::iterator it
//举例
#include<stdio.h>
#include<set>
using namespace std;
int main(){
    set<int>s;
    s.insert(3);
    s.insert(5);
    s.insert(2);
    s.insert(3);
    //提示，不支持it<s.end()的写法
    for(set<int>::iterator it = s.begin();it != s.end();it++){
        printf("%d",*it);//2 3 5
    }
    return 0;
}

注：set内的元素自动递增排序，且自动去除了重复元素
    

2.2常用函数

set<int>s;

1.insert(x):将x插入set，且自动递增排序去重，时间复杂度O(n)//在上个例子中举过例
2.find(value):返回set中对应值为value的迭代器，O(logn)
//例：
      int main(){
          set<int>s;
          for(int i=1;i<=3;i++){
                s.insert(i);
          }
          set<int>::iterator it =s.find(2);//在set中查找2，返回其迭代器
          printf("%d",*it);
          //以上也可以写成printf("%d",*(s.find(2)));
          return 0;
      }  
3.erase():也是两种删除方式
    (1)s.erase(it):删除单个元素,且it为迭代器
    //例
    s.erase(s.find(x));
    (2)s.erase(value):删除单个元素，value为删除元素的值
    //例
    s.erase(100);
    (3)s.erase(first,last):删除区间,左闭右开
    //例
    set<int>::iterator it = s.find(30);
    s.erase(it,s.end());

4.size():获取元素个数
5.clear():清空set中的所有元素

3.string

3.1定义与访问

string str;
string str = "abcd"//如果要初始化，可直接赋值

//访问
（1）可直接像字符数组一样访问下标
       for(int i=0;i<str.length();i++){
               printf("%c",str[i]); 
       }
     若要读入输出整个字符串，则只能cin和cout
       string str;
       cin>>str;
       cout<<str;
（2）通过迭代器访问//一般是函数insert(),erase()要求迭代器才用这个
       for(string::iterator it=str.begin();it!=str.end();it++){
               printf("%d",*it);
       }

        

3.2常用函数

注：string可直接用+链接

       string可直接比较

string s="abcxyz"

1. length()/size();
2. insert(pos,string):在pos号位置插入字符串string
        例:string s2="opq"
           s.insert(3,s2);
           cout<<s<<endl;//答案为abcopqxyz
   insert(it,it2,it3):
        例:string s2="opq"
           s.insert(s.begin()+3,s2.begin(),s2.end());
           cout<<s<<endl;//答案为abcopqxyz
3. erase(first,last):为迭代器，左闭右开
4. erase(pos,length):pos为需要开始删除的位置，length为删除的字符个数
5. clear();
6. substr(pos,len):返回从pos号位开始，长度为len的字串
7. s.find(s2):当s2是s的字串时，返回其在s中第一次出现位置
8. replace();

4.map(映射)

4.1构造与访问

map<typenmae1,typename2>mp;
map<string,int>mp//如果是字符串到整型的映射，必须使用string而不能用char数组
map<set<int>,string>mp;


//访问
//map中键是唯一的，有重复的键，则值被覆盖
//map会以键从小到大的顺序自动排序，这是由于map内部是使用红黑树实现的(set也是)，在建立过程中会自动实现从小到大的排序功能
int main(){
    map<char,int>mp;
    mp['c'] = 20;
    mp['c'] = 30;
    printf("%d\n",mp['c']);//输出的是30，因为被覆盖，只能存在一个键
    return 0;
}


int main(){
    map<char,int>mp;
    mp['m'] = 20;
    mp['r'] = 30;
    mp['a'] = 40;
    for(map<char, int>;:iterator it = mp.begin();it!=mp.end();it++){
        printf("%c %d\n",it->first,it->second);//按照a,m,r的顺序
    }
    return 0;
}

4.2常用函数

1. find(key):返回键为key的映射的迭代器
2. mp.erase(it):it为需要删除的元素的迭代器
3. mp.erase(key)：key为要删除的映射的键
4. mp.erase(first,last):first起始迭代器，last末尾迭代器的下一个地址，左闭右开
5. size()
6. clear()

4.3.unordered_map

//unordered_map 基于哈希表数据结构实现
//元素的排列顺序是杂乱的，无序的
//同样也是没有重复的键
unordered_map<int,string>ump;
umap[1] = "apple";
umap[2] = "banana";
//访问方式见map



//常用函数
1. insert():umap.insert({3, "orange"});

//find()方法在 unordered_map中只能查找键
2. find():返回的是迭代器
    auto it = umap.find(1);
    if (it != umap.end()) {
        cout << it->second << endl; // 输出 "apple"
    }
3. erase();//同map一样

4. map.contains(2):与find一样，但是返回的更简洁，返回的是true和false

5. size():键值对的数量