C++队列和栈用法详解

基本理论

首先最基本的是，队列是FIFO（先进先出）的，栈是FILO(先进后出)的。

很重要的一点是，在STL中往往都不把队列和栈归类为容器，而是归类为container adapter（容器适配器）。因此队列和栈的底部实现可以是deque、vector、list，而在我们常用的SGI STL中，两者均以容器deque为缺省情况下的底部结构。

// 使用vector为底层容器的栈的初始化
std::stack<int, std::vector<int>> st;

除此以外，需注意队列和栈均不允许有遍历行为，不提供迭代器。

容器deque

1. 使用deque之前需包含头文件：#include <deque>。

2. 可以把deque看作一个两头都可以进行快速插入与删除操作的双向队列。

3. deque并不像vector一样把所有对象都放在一个连续内存块中，而是多个连续的内存块中，因此deque中的元素并不是严格连续分布的。

4. 在deque中间部分插入或删除元素时需要移动所有元素，所以是相对较慢的，因此适用deque最好的情形是只需要操作两端元素，而不需要操作中间部分的元素。

5. 常用用法:

#include <deque>

deque<int> a;
deque<char> b(a);
deque<int> a(6);//创建一个具有6个值默认为0元素的deque对象
deque<int> a(6, 1);//创建一个具有6个值均为1的元素的deque对象

a.push_front(elem);//将元素elem插入队头
a.push_back(elem);
a.pop_front();
a.pop_back();
a.insert(pos, elem);//在iterator pos所指向的位置前添加元素elem
a.insert(pos, begin, end);//在iterator pos所指向的位置前添加[begin,end)间的所有元素
a.emplace_front(args);//用参数args构造一个元素并添加进队头
a.emplace_back(args);
a.emplace(pos, args);//用参数args构造一个元素并添加在iterator pos所指向的位置之前

a.erase(pos);//删除iterator pos所指向的元素
a.clear();
a.empty();

队列

queue

1. 使用queue之前需包含头文件：#include <queue>。
2. 用法：

#include <queue>
queue<int> q;
q.push(elem);//将元素elem插入队尾
q.pop();
q.emplace(args);//用参数args构造一个元素并添加进队尾
q.front();
q.back();
q.empty();
q.size();
//注意：queue本身不支持clear操作，即不存在q.clear()

priority_queue

1. 使用priority_queue所需的包含头文件的指令也是：#include <queue>。
2. priority_queue也是一种容器适配器，其底层容器可以是vector、deque，但不能是list，并且STL在缺省情况下以vector作为其底层结构。
3. 优先队列有三个模板参数：数据类型、容器类型（默认为vector）与比较算子（默认为less），其中后两者可省。
4. 值得注意的是，在默认情况下，优先队列是个大顶堆，但同时也是个降序队列，其操作均在队尾进行。
5. 用法：

#include <queue>
priority_queue<int> q;
q.push(elem);
q.pop();
q.emplace(args);
q.top();
q.empty();
q.size();
//注意：priority_queue本身不支持clear操作，即不存在q.clear()

6. 实例：

#include <iostream>
#include <queue>
using namespace std;

struct cmp { //小顶堆
    bool operator()(pair<int,int> a, pair<int,int> b) {
        if (a.second == b.second) return a.first > b.first;
        else return a.second > b.second;
    }
};

int main() {
    priority_queue<int> a; 
    //等同于 priority_queue<int, vector<int>, less<int> > a;
    priority_queue<pair<int, int>, vector<pair<int, int>>, cmp> b;

    for (int i = 0; i < 5; ++i) {
        a.push(i);
    }
    while (!a.empty()) {
        cout << a.top() << ' ';
        a.pop();
    } 
    cout << endl;

    b.push(make_pair(1, 3));
    b.push(make_pair(2, 3));
    b.push(make_pair(3, 2));
    while (!b.empty()) {
        cout << b.top().first << ' ' << b.top().second << endl;
        b.pop();
    }
    cout << endl;
    return 0;
}

输出：

4 3 2 1 0
3 2
1 3
2 3

栈stack

1. 使用queue之前需包含头文件：#include <stack>。
2. 用法：

#include <stack>
stack<int> st;
st.push(elem);
st.pop();
st.emplace(args);//用参数args构造一个元素并添加进栈顶
st.top();
st.empty();
st.size();
//注意：stack本身不支持clear操作，即不存在st.clear()

参考资料

1. deque部分参考文章：
   https://blog.csdn.net/xiajun07061225/article/details/7442816
2. priority_queue部分参考文章：
   https://blog.csdn.net/weixin_36888577/article/details/79937886