STL使用：deque双端队列

双端队列deque支持两端的插入和删除操作。由于它是动态地以分段连续空间组合而成的，所以没有容量（capacity）的概念，可以随时增加一段新的空间并链接起来。deque不会像vector那样因为旧空间不足而重新配置一块更大的空间，然后再复制元素，再释放旧空间。因此，deque也就没有必要提供所谓的空间保留（reserve）功能。

1)支持随即存取。

2)支持两端操作，push(pop)-back(front)，在两端操作上与list效率差不多。 在“中间”插入和删除元素具有与vector一样的低效率。 vector，list，deque为三种独立的容器

在实际使用时，如何选择这三个容器中哪一个，应根据需要而定，一般应遵循下面的原则：

1、如果你需要高效的随机存取，而不在乎插入和删除的效率，使用vector

2、如果你需要大量的插入和删除，而不关心随机存取，则应使用list

3、如果你需要随即存取，而且关心两端数据的插入和删除，则应使用deque。

函数：

(1) 构造函数

deque():创建一个空deque

deque(int nSize):创建一个deque,元素个数为nSize

deque(int nSize,const T& t):创建一个deque,元素个数为nSize,且值均为t

deque(const deque &):复制构造函数

(2) 增加函数

void push_front(const T& x):双端队列头部增加一个元素X

void push_back(const T& x):双端队列尾部增加一个元素x

iterator insert(iterator it,const T& x):双端队列中某一元素前增加一个元素x

void insert(iterator it,int n,const T& x):双端队列中某一元素前增加n个相同的元素x

void insert(iterator it,const_iterator first,const_iteratorlast):双端队列中某一元素前插入另一个相同类型向量的[forst,last)间的数据

(3) 删除函数

Iterator erase(iterator it):删除双端队列中的某一个元素

Iterator erase(iterator first,iterator last):删除双端队列中[first,last）中的元素

void pop_front():删除双端队列中最前一个元素

void pop_back():删除双端队列中最后一个元素

void clear():清空双端队列中最后一个元素

(4) 遍历函数

reference at(int pos):返回pos位置元素的引用

reference front():返回手元素的引用

reference back():返回尾元素的引用

iterator begin():返回向量头指针，指向第一个元素

iterator end():返回指向向量中最后一个元素下一个元素的指针（不包含在向量中）

reverse_iterator rbegin():反向迭代器，指向最后一个元素

reverse_iterator rend():反向迭代器，指向第一个元素的前一个元素

(5) 判断函数

bool empty() const:向量是否为空，若true,则向量中无元素

(6) 大小函数

Int size() const:返回向量中元素的个数

int max_size() const:返回最大可允许的双端对了元素数量值

(7) 其他函数

void swap(deque&):交换两个同类型向量的数据

void assign(int n,const T& x):向量中第n个元素的值设置为x

实例：

// deque.cpp : 定义控制台应用程序的入口点。

#include<iostream>
#include<deque>

using namespace std;
void printDeque(deque<int> d)
{
    //使用下标
    for (unsigned int i = 0; i < d.size(); i++)
    {
        cout<<d.at(i)<<"\t";//貌似使用a[i]也是可行的
    }
    cout<<endl;

    //使用迭代器
    //deque<int>::iterator iter = d.begin();
    //for (;iter != d.end(); iter ++)
    //{
    // cout<<"d["<<iter-d.begin()<<"] = "<<(*iter)<<", ";
    //}
}
int main()
{
    deque<int> d;
    d.push_back( 10 );
    d.push_back(20);
    d.push_back(30);
    cout<<"原始双端队列："<<endl;
    for(int i = 0; i < d.size(); i++)
    {
        cout<<d.at(i)<<"\t";//at()返回在特定位置元素的引用
    }
    cout<<endl;
    d.push_front(5);
    d.push_front(3);
    d.push_front(1);

    cout<<"after push_front(5.3.1):"<<endl;
    for(int i = 0;i < d.size();i++)
    {
        cout<<d.at(i)<<"\t";
    }
    cout<<endl;
    d.pop_front();
    d.pop_front();
    cout<<"after pop_front() two times:"<<endl;
    for(int i = 0;i < d.size();i++)
    {
        cout<<d.at(i)<<"\t";
    }
    cout<<endl;
    //若是采用迭代器进行输出呢？
    //使用迭代器指针
    cout<<"采用迭代器进行输出："<<endl;
    deque<int>::iterator *pIter = new deque<int>::iterator;
    if ( NULL == pIter )
    {
        return 0;
    }
    for (*pIter = d.begin(); *pIter != d.end(); (*pIter)++)
    {
        //cout<<"d["<<*pIter - d.begin() <<"]="<<**pIter<<", ";
        cout<<**pIter<<"\t";
    }
    if (NULL != pIter)
    {
        delete pIter;
        pIter = NULL;
    }
    cout<<endl;
    //进行pop_back
    d.pop_back();
    d.pop_back();
    cout<<"after pop_back two times:"<<endl;
    for(int i = 0;i < d.size();i++)
    {
        cout<<d.at(i)<<"\t";
    }
    cout<<endl;
    //测试erase操作
    //任意迭代位置或迭代区间上的元素删除用erase(&pos)/erase(&first, &last)；删除所有元素用clear();
    d.push_back(20);
    d.push_back(30);
    cout<<"先恢复，再d.erase(d.begin()+1): "<<endl;
    d.erase(d.begin()+1); //删除第2个元素d[1]，即删除10
    printDeque(d);//此时只剩下5，20，30

    //测试区间删除
    deque<int> d1;
    cout<<"New deque d1:"<<endl;
    for (int i = 1; i < 6 ; i++)
        d1.push_back(i*10);
    printDeque(d1);
    cout<<"d1.erase(d1.begin()+1, d1.begin() + 3) = "<<endl;
    d1.erase(d1.begin()+1, d1.begin() + 3);//删除双端队列中[first,last）中的元素
    printDeque(d1);

    return 0;
}

结果图如下：