deque,queue,stack,

deque与vector非常相似。它也采用动态数组管理元素，提供随机存取，有着和vector几乎一样的接口。不同的是deque的动态数组头尾都开放，因此能在头尾两端进行快速安插和删除。

deque与vector的主要不同之处在于：

1. 两端都能快速安插和删除元素，这些操作可以在分期摊还的常数时间（amortized constant time）内完成。

2. 元素的存取和迭代器的动作比vector稍慢。

3. 迭代器需要在不同区块间跳转，所以它非一般指针。

4. 因为deque使用不止一块内存（而vector必须使用一块连续内存），所以deque的max_size()可能更大。

5. 不支持对容量和内存重新分配时机的控制。不过deque的内存重分配优于vector，因为其内部结构显示，deque不必在内存重分配时复制所有元素。

6. 除了头尾两端，在任何地方安插或删除元素，都将导致指向deque元素的所有pointers、references、iterators失效。

7. deque的内存区块不再被使用时，会自动被释放。deque的内存大小是可自动缩减的。

8. deque与vector组织内存的方式不一样。在底层，deque按“页”（page）或“块”（chunk）来分配存储器，每页包含固定数目的元素。而vector只分配一块连续的内存。例如，一个10M字节的vector使用的是一整块10M字节的内存，而deque可以使用一串更小的内存块，比如10块1M的内存。所以不能将deque的地址（如&deque[0]）传递给传统的C API，因为deque内部所使用的内存不一定会连续。

deque的下述特性与vector差不多：

1. 在中部安插、删除元素的速度较慢。

2. 迭代器属于random access iterator（随机存取迭代器）。

优先使用vector，还是deque?

c++标准建议：vector是那种应该在默认情况下使用的序列。如果大多数插入和删除操作发生在序列的头部或尾部时，应该选用deque。

使用deque还需注意：

1. 除了at()，其它成员函数均不会检查索引或迭代器是否有效。

2. 任何插入或删除动作都会使所有指向deque元素的pointers、references、iteartors失效，唯一例外的是在头部或尾部插入元素（此时pointers和references仍然有效，但iterators失效）

#include <iostream>
#include <stack>
#include <queue>
#include <deque>//双端队列
#include "string.h"
#include "stdlib.h"
#include <functional>
#include <algorithm>
#include <vector>
using namespace std;

//栈后进先出
void main_1()
{
    int num;
    cin >> num;
    stack<int>mystack;
    for (; num; num /= 2)
    {
        mystack.push(num%2);
        cout << "当前元素个数" << mystack.size() << endl;
    }

    while (!mystack.empty())
    {
        cout<<mystack.top()<<" ";

        mystack.pop();

    }

    cin.get();
    cin.get();

}


//队列先进先出

//单端队列
void main_queue()
{
    queue<char *>myq;
    myq.push("calc");
    myq.push("notepad");
    myq.push("tasklist");
    myq.push("mspaint");


    while (!myq.empty())
    {
        char*p = myq.front();
        system(p);
        myq.pop();
    }


    cin.get();
}

//双端队列
void main_11()
{
    deque<int> mydq;
    mydq.push_back(1);
    mydq.push_back(2);
    mydq.push_back(3);
    mydq.push_back(4);
    mydq.push_back(5);
    mydq.push_back(6);
    mydq.insert(mydq.begin()+3,100);//插入
    mydq.push_front(0);
    mydq.push_back(7);
    mydq.erase(mydq.end()-1);

    mydq.pop_back();
    mydq.pop_front();

    //for (int i = 0; i < mydq.size(); i++)
    //{
    //  cout << mydq[i] << endl;
    //}

    //mydq.clear();
    auto ib = mydq.begin();
    auto ie = mydq.end();

    for (; ib != ie;ib++)
    {
        cout << *ib << endl;
    }


    cin.get();

}


void main_21()
{
    deque<int> mydq;
    mydq.push_back(1);
    mydq.push_back(2);
    mydq.push_back(3);
    mydq.push_back(4);
    mydq.push_back(5);
    mydq.push_back(6);

    deque<int> mydq2;
    mydq2.push_back(11);
    mydq2.push_back(21);
    mydq2.push_back(31);
    //mydq2.push_back(41);
    //mydq2.push_back(51);
    //mydq2.push_back(61);


    mydq.swap(mydq2);

    auto ib = mydq.begin();
    auto ie = mydq.end();

    for (; ib != ie; ib++)
    {
        cout << *ib << endl;
    }

    auto ib2 = mydq2.begin();
    auto ie2= mydq2.end();

    for (; ib2 != ie2; ib2++)
    {
        cout << *ib2 << endl;
    }


    cin.get();

}




struct student
{
    int age;
    char *name;
};

struct strless
{
    bool operator() (const student&s1, const student&s2)
    {
        return strcmp(s1.name,s2.name)<0;
    }
};


void main()
{
    //priority_queue<int,vector<int>,less<int>> myq;
    //myq.push(1);
    //myq.push(2);
    //myq.push(3);
    //myq.push(4);

    priority_queue<student, vector<student>,strless> myq;
    student stu[3];
    stu[0].age = 15;
    stu[0].name = "vdffv";
    stu[1].age = 16;
    stu[1].name = "asfds";
    stu[2].age = 17;
    stu[2].name = "asfds";

    myq.push(stu[0]);
    myq.push(stu[1]);
    myq.push(stu[2]);
    while (!myq.empty())
    {
        cout << myq.top().age<<"   "<<myq.top().name << endl;
        myq.pop();

    }


    cin.get();
}