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;
}

版权声明：本文博主原创文章，博客，未经同意不得转载。