STL顺序容器【vector】【deque】【list】

╰半夏微凉° 2022-08-10 14:44 130阅读 0赞

**我们都知道，stl容器中将容器分为两类，顺序容器和关联容器。**

**顺序容器有三种即动态数组vector,双端队列deque,以及链表list**

**（对csdn的文字排版严重吐槽，写好的版发表了就变了）**

**一：顺序容器的常用操作**

**1：首先顺序容器的迭代器**

**定义：T<C>::iterator iter;**

**/\*支持所有顺序容器\*/**

**\*iter//返回迭代器的引用**

**iter->mem //对iter解引用，等效于（\*iter）.men**

**++iter|iter++//自加**

**--iter|iter--//自减**

**iter1==iter2 | iter1！=iter2//比较**

**/\*只支持vector 和deque\*/**

**iter+n | iter-n迭代器加减整数值**

**iter1+=iter2 | iter1-=iter2迭代器复合运算**

**iter1-iter2迭代器减法**

**>,>=,<,<=迭代器关系符！！也可用于迭代器间比较大小**

**2:迭代器范围**

**c.begin() | c.rend()指容器中第一个元素，后面是逆序迭代器**

**c.end() | c.rbegin() 指容器最后一个元素**

**c.size()返回容器元素个数**

**c.max\_size()返回最多容纳元素个数**

**c.empty()是否为空，返回布尔值**

**c.resize(n)调整容器长度大小，使其能够容纳n个元素**

**c.resize(n,t)容纳n个元素，新添加的都是t**

**c.capacity()获取当前容器的能够存储的元素总数**

**c.reverse(n)为容器预留多少空间**

**3：容器定义的类型别名**

**size\_type无符号整形，容器长度**

**iterator迭代器类型**

**const\_iterator 只读迭代器类型**

**reverse\_iterator逆序寻址迭代器**

**const\_reverse\_iterator只读逆序寻址迭代器**

**difference\_type迭代器差值，可为负值**

**value\_type元素类型**

**reference元素左值类型**

**const\_reference常量元素左值类型**

**/\*定义方法 C<T>::类型别名 变量；**

**4：容器的初始化**

**C<T> c; 创建空容器**

**C<T> c(c2); 创建容器是从c2的副本**

**C<T> c(b,e);创建容器是迭代器b到e的副本**

**C<T> c(n,t);创建由n个t元素初始化**

**C<T> c(n);创建由n个初始化的容器**

**5：添加及删除元素**

**c.push\_back()尾部添加元素**

**c.push\_front()首部添加元素，不适用与vector**

**c.insert(p,t)迭代器p位置添加t**

**c.insert(p,n,t)迭代器p位置添加n个t**

**c.insert(p，b，e)迭代器p位置更新为某段迭代器b到e中的元素**

**删除元素**

**c.erase(p)删除迭代器p位置的元素**

**c.erase(b,e)删除迭代器b到e范围内的元素**

**c.clear()清空所有元素**

**c.pop\_back()删除容器最后一个元素**

**c.pop\_front()删除第一个元素，不适用于vector**

**6：访问容器元素**

**c.back()返回容器最后一个元素引用**

**c.front()返回第一个元素引用**

**c\[i\] | c.at(i)返回第i个元素引用,不适用于list**

**7：赋值与swap**

**c1=c2c1赋值为c2，删除c1中元素，复制c2到c1**

**c1.swap(c2)交换c1与c2中的元素**

**c.assign(b,e)用迭代器b到e的元素更新全部的c**

**c.assign(n,t)c中更新为n个t**

**二：顺序容器间的区别及容器的选用**

**1：vector和deque能够随机的访问元素，vector和deque对操作符“ \[\] ”重载了，而list没有，我们我们只能通过迭代器访问，而不能通过下标访问。**

**2：在中间位置插入元素次数较多是优先选择list，如果在首部和尾部插入较多是优先选择deque。**

**3：编程中容器可以交叉是用以提高效率，如果只是在读取的时候要在中间插入元素，而需要随机访问元素的话，我们可以用list读入，然后复制到vector中操作。**

**注意：我们知道vector是连续分配内存的，那么如果添加入新元素后这一块内存满了，那么vector必须找一块儿更大的内训，把当前的元素复制过去，然后释放之前的内存，这样的操作如果多次的话很浪费时间，解决办法是定义容器是就分配空间，适当多预留空间，那么久不会出现全部元素复制的情况。**

**三：顺序容器适配器**

**顺序容器适配器包括队列queue，栈stack和优先队列priority\_queue**

**适配器概念：使一种事物的行为类似于另一种事物**

**容器适配器概念：让一众已存在的容器类型以另一种不同的抽象类型的工作方式实现  
适配器头文件**

**\#include <queue>**

**\#include <stack>**

**适配器初始化**

**stack<int> s;初始化一个空栈**

**stack<int> stk(s);初始化为s的一个副本**

**1：栈适配器**

**首先，stack其关联容器可以是任意一种类型，可以建立在vector，deque以及list之上，默认deque。**

**queue要求支持push\_front（），所以只能在list之上和deque，默认deque。**

**priority\_queue要求提供随机访问，所以可以建立在vector和deque之上，默认vector。**

**可以根据实际的让他们建立在许可的容器之上，定义方法：**

**stack<char,vector<char> > s; //注意后面两个>>必须分开，否则会认为是输出流**

**1：栈支持的操作：**

**s.empty()判空**

**s.size()返回元素个数**

**s.pop()删除栈顶元素**

**s.top()返回栈顶元素**

**s.push()压入栈顶**

**2：队列及优先队列操作**

**s.empty()判空**

**s.size()返回元素个数**

**s.pop()删除队首元素**

**s.front()返回队首元素，只用于队列**

**s.back()返回队尾元素，只用于队列**

**s.top()返回最高优先级元素，只用于优先队列**

**s.top()返回栈顶元素**

**s.push()压入队列**

**优先队列优先级定义默认用'<'，操作符，定义方法：**

<span style="font-size:10px;">struct Node
    {
        int num;
        int cycle;
        int count;
        int zong;
        bool operator < (const Node &a) const  //比较函数
        {
            return a.zong<zong;   //首先按zong从小到大，然后按num从小到大！
            return a.num<num;
        }
    };</span>

**顺序容器练习代码：**

#include <cstdio>
    #include <cstring>
    #include <iostream>
    #include <string>
    #include <algorithm>
    #include <vector>
    #include <queue>
    #include <list>
    using namespace std;
    #define Del(a,b) memset(a,b,sizeof(a))
    const int N = 11000;
    
    int main()
    {
        /*9.1.1*/
        vector<int> ievel;
        vector<string> svec;//(get_word_count("Chimera"));
        svec.push_back("i ccc");
        svec.push_back("yang can");
        svec.insert(svec.begin()+1,"momo");
        svec.insert(svec.begin()+1,5,"hahha");
        string s[10]={"what","is","your","name"};
        svec.insert(svec.begin()+1,s,s+4);
        vector<string>::iterator i=svec.begin();
        svec.erase(i+0);
        //svec.erase(i,i+2);
        for(int i=0;i<svec.size();i++)
            cout<<svec[i]<<endl;
        cout<<"---->"<<svec[10]<<endl;
        cout<<"xxxxx"<<svec.at(10)<<endl;  //另一种访问办法，下标超抛出out_of_range
        /*vector<string>::const_reverse_iterator ii;
        for(ii=svec.rbegin();ii!=svec.rend();ii--){
            cout<<*ii<endl;
        }*/
        /*list<string> slist(svec.begin(),svec.end());
        list<string>::iterator it;
        for(it=slist.begin();it!=slist.end();it++)
            cout<<*it<<endl;
        const list<int>::size_type ll=64;//注意类型
        list<string> ls(ll,"eh?");
        for(it=ls.begin();it!=ls.end();it++){}
            //cout<<*it<<endl;
        /*9.1.2
        vector<vector<string> > v;
        vector<string> s1;
        v.push_back(s1);*/
        list<int> lis(10,42);
        lis.resize(15); //调整容器大小
        lis.resize(25,-1); //可选参数初始值
        //lis.resize(5);
        list<int>::iterator it=lis.begin();
        for(;it!=lis.end();it++)
        {
            cout<<*it<<endl;
        }
        return 0;
    }

容器适配器练习代码：

#include <cstdio>
    #include <cstring>
    #include <algorithm>
    #include <queue>
    #include <stack>
    using namespace std;
    
    struct Node
    {
        int x;
        bool operator < (const Node &a) const
        {
            return a.x<x;   //首先按zong从小到大
        }
    };
    
    int main()
    {
        priority_queue<Node> p;
        Node s;s.x=5;
        p.push(s);
        s.x=10;
        p.push(s);
        s.x=1;p.push(s);
        while(!p.empty())
        {
            printf("%d\n",p.top());
            p.pop();
        }
        return 0;
    }