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

我们都知道，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;
}