接着介绍另一种线性容器双向队列deque，双向队列是一种非常灵活的容器支持队头和队尾进出操作。当对双向队列进行一定的限制就衍生出队列和栈。其中队列仅支持队尾入队和队头出队满足条件先进先出，栈仅支持单向入出队满足条件后进先出。
如图所示：

常用方法：

deque:
push_back();	//尾部入队
push_front();	//头部入队
pop_back();		//尾部出队
pop_front();	//头部出队
back();			//获取尾部元素
front();		//获取头部元素
......

--------------------------------
queue：
push();		//队尾入队
pop();		//队头出队
back();		//获取尾部元素
front();	//获取头部元素
......

--------------------------------
stack:
push();		//队尾入队
pop();		//队头出队
top();		//获取栈头元素
......

实例可执行代码：

//
// Created by wsk on 25-10-21.
//
#include <iostream>
#include <deque>
#include <algorithm>
using namespace std;

int main()
{
    deque<int> mydeque(10,9);
    for (int i=0;i<mydeque.size();i++)
    {
        cout << mydeque[i] << " ";
    }
    cout << endl;
    cout << mydeque.size() << endl;
    mydeque.push_back(6);
    mydeque.push_front(7);
    for (int i=0;i<mydeque.size();i++)
    {
        cout << mydeque[i] << " ";
    }
    cout << endl;
    auto it = find(mydeque.begin(),mydeque.end(),7);
    if (*it)
    {
        mydeque.erase(it);//擦除 9 9 9 9 9 9 9 9 9 9 6
        // mydeque.erase(it,it+4);//擦除一个区间左闭右开 9 9 9 9 9 9 9 6
    }
    auto it2 = find(mydeque.begin(),mydeque.end(),6);
    if (*it2)
    {
        mydeque.insert(it2,66);// 9 9 9 9 9 9 9 9 9 9 66 6
    }
    for (int i=0;i<mydeque.size();i++)
    {
        cout << mydeque[i] << " ";
    }
    cout << endl;
    // mydeque.pop_back();
    mydeque.pop_front();
    for (int i=0;i<mydeque.size();i++)
    {
        cout << mydeque[i] << " ";
    }
    cout << endl;
    int temp = mydeque.front();
    cout << temp << endl;
    cout << mydeque.back() << endl;
    mydeque.clear();
    cout << mydeque.size() << endl;
    return 0;
}

//
// Created by wsk on 25-10-22.
//
#include <iostream>
#include <queue>
using namespace std;

int main()
{
    queue<int> myqueue;
    queue<int> myqueue2;
    myqueue.push(1);
    myqueue.push(3);
    myqueue.push(5);
    myqueue2.push(2);
    myqueue2.push(4);
    myqueue2.push(6);
    cout<<myqueue.front()<<endl;
    cout<<myqueue.back()<<endl;
    // myqueue.pop();
    cout <<"size = " << myqueue.size() << endl;
    myqueue.swap(myqueue2);// 队列元素互换
    cout<<myqueue.front()<<endl;
    cout<<myqueue.back()<<endl;
    return 0;
}

//
// Created by wsk on 25-10-22.
//
#include <iostream>
#include <stack>
using namespace std;

int main()
{
    stack<int> mystack;
    mystack.push(1);
    mystack.push(2);
    mystack.push(3);
    for (int i=0;i<3;i++)
    {
        int temp = mystack.top();
        cout << temp << endl;
        mystack.pop();
    }
    cout << mystack.size() << endl;
    return 0;
}

接着介绍一种特殊的队列-优先队列，它是按照一定规则来确定元素的先后顺序。以priority_queue容器为例，其底层容器默认是vector底层排序逻辑默认是一个大根堆不过输入和输出是按照队列的规则。
下面是一个例子：
可执行代码：

//
// Created by wsk on 25-10-22.
//
#include <iostream>
#include <queue>
#include <vector>

using namespace std;
//自定义类型
struct People
{
    int age;
    string name;
    // 定义小根堆比较规则（按年龄升序）
    bool operator<(const People& other) const {
        return age > other.age; // 注意：返回true时当前对象优先级更低
    }

};
int main()
{
    vector<int> vec = {0,1,2,3,4,8,9,3,5};
    priority_queue<int> pq(vec.begin(), vec.end());// 9 8 5 4 3 3 2 1 0
    pq.push(11);
    while (!pq.empty())
    {
        cout << pq.top() << " ";
        pq.pop();// 弹出top元素后都要调整堆
    }
    cout << endl;
    cout << pq.size() << endl;

    // const People per01 = {15, "jim"};
    // const People per02 = {16, "rose"};
    // priority_queue<People> pq01;
    // pq01.push(per01);
    // pq01.push(per02);
    // const People per03 = {11, "jack"};
    // pq01.push(per03);
    // for (int i=0;i<pq01.size();i++)
    // {
    //     cout << pq01.top().name<< ":" << pq01.top().age << " ";
    // }
    // cout << endl;
    // while (!pq01.empty())
    // {
    //     cout << pq01.top().name<< ":" << pq01.top().age << " ";
    //     pq01.pop();// 弹出top元素后都要调整堆
    // }
    // cout << endl;
    // cout << pq01.size() << endl;
    return 0;
}