C++中常用的STL容器及使用方法整理(更新中)

一.vector

1.定义：vector<类型名>数组名;
     如：vector<int>name;
     
2.初始化
2.1.vector<类型名>数组名(数组元素个数)
     如：vector<int>name(10);//创建数组name,元素个数为10
2.2.vector<类型名>数组名(数组元素个数,初始值)
     如：vector<int>name(10,1);//创建数组name,元素个数为10,各元素初始化为1
2.3.vector<类型名>数组名(另一相同类型的数组)
     如：vector<int>name(10,0);
     vector<int>name2(name);//创建出跟name数组一样的name2数组
     
3.访问：
3.1.类似数组通过下标访问
    如：name[0]=1;
    再如：for(int i=0;i<name.size();i++){
         //插入对每个变量的操作
         }
3.2.通过迭代器访问
    迭代器可以想象成元素的指针，用*号引用可以表示元素(只有vector和下面的set和string类支持*引用)
    auto c=name.begin();//auto会自动判断类型
    printf("%d",(*c));//打印name数组的第一个元素
        
4.常用函数
4.1.push_back(插入的元素)：back即”后面”的意思，因此这个函数是把元素插入数组最后
    如:name.push_back(1)//在name数组最后插入新元素”1”
4.2.pop_back()：弹出最后一个元素
    如:name.pop_back()//弹出name数组最后一个元素
4.3.size()：返回数组大小，因为是”大小”，所以返回的是数字而非迭代器
    如:int length=name.size()//将name数组的大小赋给length
4.4.end()：返回数组最后一个元素的下一个位置的迭代器，注意是最后一个元素的下一个位置，可以理解成char字符串的’\0’
4.5.begin()：返回数组第一个元素的迭代器
    如:for(auto i=name.begin();i!=name.end();i++){
       //遍历数组每个元素要进行的操作
       }
    //这个for循环的意思就是，从name数组的第一个元素(begin)出发，遍历到最后一个元素
    //遍历到最后一个元素，进行完for内的操作后，i自增，此时到达最后一个元素的下一个位置
    //跟  i!=name.end()  条件不符，退出循环       
4.4.clear()：清空数组
    如：name.clear();
    清空只是形式上的清空，即改变指针的位置,如你查询数组的size(),会返回0，但元素仍可以访问
4.5.insert(插入位置的迭代器，插入元素)：插入元素
    如：name.push(name.begin()+2,1);
    //将”1”插入name数组第一个元素的位置向后移动两个位置，即插入name[3]的位置，原先a[3]及后面元素后移一位
4.6.erase():
    erase(删除元素位置的迭代器)
    erase(删除元素序列开始位置的迭代器，删除元素序列结束位置的下一个位置的迭代器)：删除数组元素
    如：erase(name.begin());//删除数组第一个元素
       erase(name.begin(),name.begin()+2)//删除name[0],name[1],即传入的序列是左闭右开的

二.set

1.定义：set<类型名>集合名
    如：set<int>name;
    
2.访问：只能通过迭代器访问,并且可以通过*号引用

3.常用函数
3.1.insert(插入的元素)：插入元素，插入后会自动按升序排序
    如:name.insert(2);
       name.insert(1);
       printf("%d",*name.begin());//输出第一个元素，即1
3.2.find():
    find(要查找的元素)：查找元素，返回对应值的迭代器，找不到则会返回end()迭代器(全部元素都找了一遍没找到，所以指向最后一个元素的下一个位置)
    如:int result=name.find(3);//寻找3，此时name数组中没有3
       int symbol=(result==name.end());
       //二者对比，相等的话为1，否则为0，并把值赋给symbol
       printf("%d",symbol);//输出的结果是1
3.3.erase()：删除元素，用法与vector类似
3.4.size()：返回集合的元素数量，因为是数量，所以返回的是数字,用法与vector类似
3.5.clear()：清空集合,用法与vector类似

三.string

1.定义：string 字符串名;
      如 string name;
      
2.初始化：string 字符串名="字符串内容"
      如：string name="我是略略略";
      
3.访问：支持下标和迭代器访问,同vector.
       另外，string支持直接比较(==、>=、<=)及连接(+=)
       直接比较时，比较的是两个字符串的字典序，字典序可以理解成两个对应字符的ASCII码顺序，若对应的字符相等，则比较长度。若一个字符串是另一个字符串的前缀，则长的字符串比较的值大。
       如：string s1="a",a2="aa";
           printf("%d",s2>s1);//输出的值为1
       连接即直接把字符串相连
           string s1="a";
           s1+="b";
           printf("%s",s1.cstr());
           //因为C语言没有string，所以需要用cstr方法，输出为结果“ab”
           
4.常用函数
4.1.length()/size()：返回string中存放的字符数，二者使用方法一致
4.2.insert():
    insert(插入位置的下标，欲插入的string)
    insert(原字符串插入位置的迭代器，欲插入的string开始位置的迭代器，欲插入的string结束位置的下一位的迭代器)
      如：string a="I lvelvelev";
         a.insert(1,"am");
         printf("%s",a.c_str());//输出结果为"Iam lvelvelev"
   
         string a="I 6";
         string b="am very";
         a.insert(a.begin()+1,b.begin(),b.end());
         printf("%s",a.c_str());
   //输出结果为”Iam very 6”，注意，这里要插入的字符串的首尾迭代器也是遵循左闭右开原则
4.3.erase():
    erase(要删除元素的迭代器)
    erase(删除区间的起始迭代器，删除区间最后一个元素下一位的迭代器)
    erase(删除区间开始位置的下标，删除区间的字符个数)
      如：string a="smile";
          a.erase(a.begin());
          cout<<a;//输出结果为"mile"

         string b="Iamnot6";
         b.erase(b.begin()+3,b.end()-1);
         cout<<b;//输出为”Iam6"
         
         string c="66654321";
         c.erase(3,5);
         cout<<c;//输出为“666”
4.4.clear()：清空string中的数据
4.5.substr()
    substr(返回字符串开始下标，返回字符串的长度)
      如：string c="12345666";
          cout<<c.substr(5,3);//输出为666
    
4.6.find()
    find(要查找的字符串)
    find(要查找的字符串,查找开始的下标)
4.7.replace():将字符串部分区间替换成另一字符串
    replace(被替换区间起始位置的下标，被替换的区间长度，要替换的字符串)
    replace(被替换区间的起始迭代器，被替换区间最后一个位置下一位的迭代器，替换的字符串)
      如：string a="Iambad";
          a.replace(3,3,"666");
          //等同于a.replace(a.begin()+3,a.end(),"666");
          cout<<a;//输出为Iam666               

四.map

1.定义：map<键类型,值类型>映射容器名,map本质上是键值对，键可以简单理解成数组的下标，值就是数组中的元素
        如：map<char,int>stu;
        //定义了一个以char型元素为键、以int型元素为值的名为stu的映射
        
2.存入元素与访问
2.1.存放元素:映射名[键]=元素
        如：stu['A']=100；
        //设stu已定义，A这个键对应的值为100，存入stu这个映射容器中
        //可以理解成：这是学生A与成绩的映射关系，我通过学生A这个键可以找到他的分数100
2.2.访问元素
2.2.1.通过下标(键)进行访问
        如：stu['A']=100；
           int score=stu['A'];
           printf("%d",score);//输出为”100”
2.2.2.通过迭代器访问
        如：stu['A']=100;//假设stu容器之前为空
            printf("%d",stu.begin()->second);
            //map容器会把映射的键设为迭代器的first值，映射的值设为迭代器的second值
            //这里要用剪头运算符－>，对于点运算符和剪头运算符，可以简单理解为：
            //点运算符应用于 变量 ，剪头运算符应用于 指针 (个人理解) 
            
3.常用函数
3.1.find()：返回键对应的迭代器
    find(键)
    如：stu['A']=100;
       auto temp=stu.find('A');
       printf("%d",temp->second);//输出结果为“100”
3.2.erase()：删除映射中的键值对
    erase(待删除映射的迭代器)
    erase(待删除映射的键)
    erase(待删除映射区间的起始迭代器，待删除映射区间的最后一个迭代器的下一个迭代器)
    如：stu['A']=100;//假设stu容器之前为空
       stu['B']=200;
       stu['C']=300;
       stu['D']=400;
       stu.erase(stu.begin());//删除’A’对应的映射
       stu.erase('B');//删除’B’对应的映射
       stu.erase(stu.begin(),stu.find('D'));
       //删除第一个元素到’D’之前的一个元素，即删除‘C’对应的元素
       printf("%d",stu.begin()->second);
       //剩下‘D’对应的元素，所以输出结果为“400”
3.3.size()：返回映射的数量
3.4.clear()：清空所有映射

五.queue

1.定义：queue<类型名>队列名
       如：queue<int>q;
       
2.访问元素：
2.1.访问队头元素：q.front();//返回队头元素
2.2.访问队尾元素：q.back();//返回队尾元素
    如：q.push(2);//假设队列q之前为空
       q.push(3);//push()函数稍后介绍
       cout<<q.front()<<' '<<q.back()<<endl;//输出结果为“2 3”

3.常用函数
3.1.push()：把元素加入队尾
3.2.pop()：弹出队头元素，注意是弹出而非返回，可以理解为删除
3.3.empty()：返回bool值，如果队列为空则返回true，否则返回false
3.4.size():返回队列中元素的个数
3.5.front(),back()：返回队头、队尾元素
    如：q.push(1);//假设队列q之前为空，此时"1"入队
       q.push(2);//"2"入队，此时"1"为队头，"2"为队尾
       int temp=q.front();
       cout<<temp<<' '<<q.size()//输出结果为“1 2”

六.priority_queue

1.定义：priority_queue<类型>队列名
       priority_queue是优先级队列，是通过”堆”这种数据结构实现的，这种数据结构可以以很高的效率对元素进行排序并筛选出其中的最大值
       如：priority_queue<int>q;
       
2.访问元素：top()函数，注，优先级队列没有front()和back()方法
        q.push(1);//假设队列为空，此时“1”入队
        cout<<q.top();//输出结果为“1”
        
3.常用函数
3.1.push()：将元素加入队尾
3.2.pop()：队首元素出队
3.3.top()：返回队头元素,所谓队头队尾并非按照进入顺序排序，而是按照值的大小排序
3.4.empty()：返回值为bool类型，队列为空则返回true，否则返回false
3.5.size()：返回优先级队列中元素个数

4.优先级队列的排序
    如果变量类型是数字，优先级队列默认选择大的排在前，如果变量类型是字符，优先级队列选择字典序大的排在前
    这涉及到了优先级队列第二种定义方式：
    priority_queue<变量类型，堆的承载容器类型，排序方式>优先级队列名
    如：priority_queue<int,vector<int>,greater<int>>q
    其中优先级队列本质上还是由数组承载的，而堆是优先级队列的底层数据结构，因此堆的承载容器类型是就是数组
    排序方式有greater和less两种，前一种表示元素小的优先级越大，即会把最小的元素放在队首，后一种表示元素大的优先级越小，即会把最小的元素放在队首
    如：priority_queue<int,vector<int>,greater<int>>q;
       q.push(3);
       q.push(1);
       q.push(2);
       cout<<q.top();//输出结果为“1”
    而自定义的结构体元素的排序方式可以在结构体外通过嵌在cmp的结构体进行定义：
    如：struct stu{
           string name;
           int score;
       };
       struct cmp{
           bool operator()(stu s1,stu s2){
               return s1.score>s2.score;
           }
       };//main函数外的部分
      //以下为main函数内的部分 
       priority_queue<stu,vector<stu>,cmp>student;
       stu t1,t2,t3;
       t1.name="A";
       t1.score=90;
       t2.name="B";
       t2.score=100;
       t3.name="C";
       t3.score=70;
       student.push(t1);
       student.push(t2);
       student.push(t3);
       printf("%d",student.top().score);//输出结果为“70”
       //这个地方我也不太懂，最近忙着准备考研复试，等过后空闲一些再研究研究具体的语法吧，待更新......

七.stack

1.定义：stack<元素类型>栈名
如：stack<int>s;

2.访问元素：只能通过top()方法访问栈顶元素
如：s.push(1);//假设栈此前为空，此时“1”入栈
    cout<<s.top();//输出结果为“1”
    
3.常用方法：
3.1.push(压入栈的元素):将元素压入栈
3.2.top()：返回栈顶元素
3.3.pop()：弹出栈顶元素，注意是弹出而非返回
3.4.empty()：返回值类型为bool，栈为空则返回true，否则返回false
3.5.size()：返回栈内元素个数
如：s.push(1);
   s.push(2);
   s.push(3);
   cout<<s.top()<<" ";
   s.pop();
   cout<<s.top()<<" ";
   s.pop();
   s.pop();
   cout<<s.empty();
   //返回结果为“3 2 1”(由于最后栈s为空，所以返回true，即为1)

八.pair

1.定义：pair<元素1的类型，元素2的类型>容器名
如：pair<string,int>people
//可以简单的把pair当做一个拥有名为first和second两个成员的结构体，而成员类型可以由自己指定

2.赋值：p.first=元素1的值，p.second=元素2的值

3.比较：pair类型之间可以通过==、<=、>=等比较符号比较大小，比较的规则是先比较first成员，相等的话比较second成员

九.常用方法

1.sort:
1.1.数组:sort(数组首地址,数组尾地址的下一个位置)
1.2.vector容器:sort(vector.begin(),vector.end())