企业官网建设流程全解析

1. 队列与栈：最基础也最容易被低估的两种结构

很多人学C++数据结构时，总觉得队列和栈太简单——一个先进先出，一个先进后出，背个定义就能应付考试。但等你真正写代码、调bug、设计系统时才会发现，这两个“简单”的结构几乎无处不在：函数调用的底层依赖栈，消息系统的核心依赖队列，线程池的任务缓冲依赖阻塞队列，甚至连编译器的表达式求值、浏览器的前进后退、操作系统的中断处理，背后全是它们的身影。

这篇文章不是教科书式的概念复读，而是结合我这些年用C++刷题、写业务代码、造轮子时积累的实际经验，把队列和栈从原理到实现、从基础到进阶、从理论到实战完整梳理一遍。无论你是刚学数据结构的学生，还是准备面试的求职者，或者在工作中需要自己实现队列栈的老兵，都能从中拿到可以直接用的东西。

我会重点讲清楚几个容易让人卡壳的点：循环队列为什么用“rear和length”而不是front和rear、单调栈到底解决了什么问题、栈回溯和中断栈针在真实程序里扮演什么角色、线程池里的阻塞队列为什么直接决定系统吞吐量。这些都是网上资料讲得比较零散、但实际又特别重要的内容。

2. 先把最基础的讲透：队列和栈的本质与物理实现

2.1 逻辑结构决定了操作规则

队列（Queue）和栈（Stack）都是线性表，但操作受限。

队列只能在队尾插入（入队/Enqueue），在队头删除（出队/Dequeue），所以先进来的元素先出去——FIFO（First In First Out）。你可以把它理解成奶茶店排队：先到的人先点单，后到的人排在后面，谁也不能插队。

栈只能在栈顶插入（压栈/Push）和删除（弹栈/Pop），所以后进来的元素先出去——LIFO（Last In First Out）。这就像一叠盘子，你总是先拿最上面那个，最后放上去的盘子最先被拿走。

这个“操作受限”是它们的灵魂。正因为限定了入口出口，很多复杂问题才能用简单的规则解决，比如括号匹配、表达式求值、深度优先搜索（DFS）天然用栈，广度优先搜索（BFS）天然用队列。

2.2 顺序存储：数组实现栈和队列

C++里最快上手的实现就是数组。

栈用数组实现非常简单，只需要一个栈顶指针top：

// 固定容量版本的栈 template<typename T> class MyStack { private: T* data; int capacity; int top; // 栈顶索引，-1表示空栈 public: MyStack(int cap) : capacity(cap), top(-1) { data = new T[cap]; } ~MyStack() { delete[] data; } bool push(const T& val) { if (top >= capacity - 1) return false; // 栈满 data[++top] = val; return true; } bool pop(T& out) { if (top < 0) return false; // 栈空 out = data[top--]; return true; } bool isEmpty() const { return top == -1; } bool isFull() const { return top == capacity - 1; } };

这段代码虽然简单，但有一个很容易被忽略的细节：data[++top]是先移动指针再赋值，data[top--]是先取值再移动指针。这种写法把入栈出栈合并成一行，性能上没有任何差别，但语义上更容易读明白。

队列用数组实现就不是那么“无脑”了。如果简单地把tail指针往后移，出队时front也跟着往后移，很快tail就会撞到数组末尾，但数组前面空着一大片。这时候两种解决方案：

1. 出队时把所有元素往前搬——时间复杂度O(n)，太浪费。
2. 使用循环队列——逻辑上把数组首尾相连，front和rear在环形空间里绕圈。

循环队列是面试和考试的高频点，尤其是网上常搜到的“假设以数组q[m]存放循环队列中的元素，同时以rear和length分别指示环形队列中的队尾和长度”这种描述，其实就是在考察你对循环队列两个关键指标的理解。

2.3 循环队列为什么用rear和length更不容易翻车

循环队列最常见的写法是用front和rear两个指针区分队空和队满。但这里有个坑：当front == rear时，究竟是队空还是队满？你不得不牺牲一个存储单元来判断：

// 牺牲一个元素空间的循环队列 // front == rear 表示空 // (rear + 1) % m == front 表示满

牺牲一个格子有点肉疼。更优雅的做法是额外记录当前长度length。这样front和rear的语义可以简化——front指向队头，rear指向队尾的下一个位置，length记录元素个数。

template<typename T> class CircularQueue { private: T* data; int capacity; int front; // 队头索引 int rear; // 队尾下一个位置索引 int length; // 当前元素个数 public: CircularQueue(int m) : capacity(m), front(0), rear(0), length(0) { data = new T[m]; } ~CircularQueue() { delete[] data; } bool enqueue(const T& val) { if (length == capacity) return false; // 队满 data[rear] = val; rear = (rear + 1) % capacity; length++; return true; } bool dequeue(T& out) { if (length == 0) return false; // 队空 out = data[front]; front = (front + 1) % capacity; length--; return true; } int size() const { return length; } };

注意关键点：rear = (rear + 1) % capacity，取模操作就是让rear在到达数组末尾后跳回头部，实现环形绕圈。length作为元素个数的独立记录，让队空队满的判断变得非常直观，不再需要纠结“front==rear是不是队满”。

这种实现方式在LeetCode的循环队列题目、数据结构期末复习、操作系统环形缓冲区（比如pipe管道）里都会遇到。我建议你亲手实现至少两遍：一遍用front/rear+牺牲单元，一遍用rear+length，对比一下差异，考试和面试时就能秒答。

2.4 链式存储：链表实现的队列和栈

数组实现有容量限制，链表实现则是动态扩容，更贴近生产环境。

链表栈其实就是带头节点的单链表，在头节点后插入、删除。时间复杂度都是O(1)：

template<typename T> class LinkedStack { private: struct Node { T data; Node* next; Node(const T& v, Node* n = nullptr) : data(v), next(n) {} }; Node* head; // 头节点 public: LinkedStack() : head(new Node(T())) {} void push(const T& val) { Node* node = new Node(val, head->next); head->next = node; } bool pop(T& out) { if (head->next == nullptr) return false; Node* del = head->next; out = del->data; head->next = del->next; delete del; return true; } };

链表队列稍微讲究一点：队头在链表头，队尾在链表尾。出队操作删除头节点，入队操作在尾节点后插入。为了入队达到O(1)，需要额外维护一个tail指针。

template<typename T> class LinkedQueue { private: struct Node { T data; Node* next; Node(const T& v, Node* n = nullptr) : data(v), next(n) {} }; Node* head; // 队头 Node* tail; // 队尾 int count; public: LinkedQueue() : head(nullptr), tail(nullptr), count(0) {} ~LinkedQueue() { while (head) { Node* del = head; head = head->next; delete del; } } void enqueue(const T& val) { Node* node = new Node(val); if (tail) tail->next = node; else head = node; tail = node; count++; } bool dequeue(T& out) { if (head == nullptr) return false; Node* del = head; out = del->data; head = head->next; if (head == nullptr) tail = nullptr; delete del; count--; return true; } };

这段代码里有个容易出bug的细节：当队列从只有一个节点变成空时，必须把tail也置为nullptr。很多人只更新head忘了tail，结果下一次enqueue时tail还是指向被删除的节点，导致链表断裂。我实测过，这个问题在面试手写代码时非常容易暴露。

3. 栈的进阶玩法：单调栈与栈回溯

3.1 单调栈：暴力枚举的优雅替代

单调栈是栈这个基础结构上推出来的高级技巧，专门解决“找左边/右边第一个比当前值大或小的元素”这类问题。经典题目如接雨水、柱状图中最大的矩形、每日温度，都能用单调栈把O(n^2)的暴力枚举优化到O(n)。

以“每日温度”为例，问题描述：给你一串温度，输出每天需要等多少天才能等到比这天更高的温度。

暴力做法是双重循环，对每个元素往后扫描，时间复杂度O(n^2)。数据一大就超时。单调栈的做法：

vector<int> dailyTemperatures(vector<int>& temperatures) { int n = temperatures.size(); vector<int> ans(n, 0); stack<int> st; // 存下标，栈底到栈顶单调递减（存温度的话是递减） for (int i = 0; i < n; ++i) { // 当前温度比栈顶对应温度高，说明找到了栈顶元素的“下一个更高温” while (!st.empty() && temperatures[i] > temperatures[st.top()]) { int idx = st.top(); st.pop(); ans[idx] = i - idx; } st.push(i); } return ans; }

核心思想：当新元素比栈顶大时，栈顶元素的答案就确定了，于是弹出；弹出的元素永远不会再被用到。每个元素最多入栈一次、出栈一次，所以整体O(n)。

理解了这个，再看“接雨水”就会很顺：从左到右遍历，维护一个单调递减栈，当当前高度大于栈顶高度时，说明栈顶所在位置形成了一个可以接水的“坑”，根据左右边界高度差计算水量。

我个人的学习建议是：不要死记模板，手动模拟一遍整个出栈入栈过程。拿纸笔画，把每个下标的具体变化写出来，跑两三个例子以后，你自然能体会到单调栈为什么能“淘汰”无效元素。这也是我教学中反复强调的地方。

3.2 栈回溯：函数调用的底层机制

“backtrace栈回溯”这个热词晒出了栈在系统层面的真实应用。程序每一次函数调用，都会在栈上开辟一个栈帧（Stack Frame），保存函数的参数、局部变量、返回地址。当函数返回时，栈帧被弹出，控制权回到调用方。

栈回溯（Stack Backtrace）就是沿着当前栈帧一步步往前回溯，打印出调用链。调试器里最常见的“调用堆栈窗口”、程序崩溃时生成的core dump里能看到出错位置，靠的都是栈回溯。

C++里让程序崩溃时自动打印调用栈，可以用unwind相关API，或者用backtrace函数族（libc库中，非标准C++但GCC/Clang环境可用）：

#include <execinfo.h> #include <signal.h> #include <unistd.h> #include <stdlib.h> void handler(int sig) { void* buffer[32]; int n = backtrace(buffer, 32); char** symbols = backtrace_symbols(buffer, n); for (int i = 0; i < n; ++i) { fprintf(stderr, "%s\n", symbols[i]); } free(symbols); _Exit(1); } int main() { signal(SIGSEGV, handler); // 触发一个野指针访问 int* p = nullptr; *p = 42; return 0; }

但注意：backtrace_symbols输出的是符号地址，如果没有加入-g编译选项，很多信息可能只有地址没有函数名。配合addr2line工具可以解析出文件名和行号。这个操作在排查线上崩溃问题时非常有用。

那“中断栈针”是什么？这个词其实是“中断栈帧”或“Interrupt Stack Frame”的常见误写。当CPU发生中断时，硬件会自动把当前上下文（寄存器、标志位、返回地址）压入内核栈或任务栈，形成中断栈帧。中断处理完毕后，恢复这些状态继续执行。整个过程也是栈的经典应用。

在嵌入式开发和RTOS中理解中断栈帧特别重要，因为栈溢出往往发生在中断嵌套时。给中断服务程序分配栈空间时，一定要把嵌套深度算进去。

3.3 递归与栈：所有递归都能改成非递归

理解栈后，递归的本质就彻底明白了。每递归一次，系统就压入一个栈帧。递归深度太大，栈空间耗尽，程序就崩溃——也就是常说的栈溢出。

比如经典的二叉树前序遍历，递归写法很短：

void preorder(TreeNode* root) { if (root == nullptr) return; visit(root); preorder(root->left); preorder(root->right); }

在实际工程里，树深度可能到数万层，递归直接爆栈。改成显式栈迭代写法：

void preorder(TreeNode* root) { if (!root) return; stack<TreeNode*> st; st.push(root); while (!st.empty()) { TreeNode* node = st.top(); st.pop(); visit(node); // 栈是后进先出，所以先压右再压左 if (node->right) st.push(node->right); if (node->left) st.push(node->left); } }

这里有一个极其重要的点：先压右子树再压左子树。因为栈是后进先出，后压入的左子树会先出栈，这样才能确保遍历顺序和递归版本一致。我见过无数人在这里写反，结果遍历顺序变成中序或者乱了。

递归改迭代是面试的高频题型，同时也是检验你对栈理解深不深的试金石。掌握“手动用栈模拟系统栈”的能力以后，逆波兰表达式计算、函数调用栈深度计算这类题目都不在话下。

4. 队列在生产环境的重头戏：阻塞队列与线程池

4.1 为什么需要阻塞队列

普通队列在并发环境下不能直接共享，因为多线程同时读写队列会造成数据竞争。于是产生了线程安全的阻塞队列（Blocking Queue）。阻塞队列不仅保证线程安全，还具备两个特殊行为：

• 队列满时，入队线程被阻塞，直到队列有空间。
• 队列空时，出队线程被阻塞，直到队列有新元素。

这种“满了等一等，空了等一等”的语义，天然适合生产者-消费者模型。生产者和消费者的速度往往不一致，阻塞队列就是二者之间的缓冲垫。

C++11没有内置阻塞队列，但用mutex和condition_variable自己实现一个并不难：

#include <queue> #include <mutex> #include <condition_variable> template<typename T> class BlockingQueue { private: std::queue<T> q; std::mutex mtx; std::condition_variable notFull; std::condition_variable notEmpty; int capacity; public: explicit BlockingQueue(int cap) : capacity(cap) {} void push(const T& val) { std::unique_lock<std::mutex> lock(mtx); // 队列满则等待 notFull.wait(lock, [&]{ return q.size() < capacity; }); q.push(val); notEmpty.notify_one(); } T pop() { std::unique_lock<std::mutex> lock(mtx); notEmpty.wait(lock, [&]{ return !q.empty(); }); T val = q.front(); q.pop(); notFull.notify_one(); return val; } bool empty() { std::lock_guard<std::mutex> lock(mtx); return q.empty(); } };

这段代码里最值得学习的是条件变量的用法。notFull.wait(lock, 谓词)有双重作用：先判断谓词，如果false就释放锁并阻塞；被唤醒后重新获得锁再次判断谓词。这防止了“虚假唤醒”（spurious wakeup），比裸用wait()安全得多。

4.2 线程池的阻塞队列选择

线程池（Thread Pool）是阻塞队列最经典的工程落地。线程池维护一组工作线程，任务提交到阻塞队列，空闲线程从队列取任务执行。

网上高频热搜词“线程池的阻塞队列选择”，这其实是面试中的经典点。不同线程池实现会选择不同策略：

• 无界队列（如C++自己实现的“无限容量”队列）：任务永不拒绝，但任务堆积会占满内存，响应延迟变高。
• 有界队列：容量固定，容量满时可拒绝任务或执行丢弃策略。实际系统多用有界队列。
• 优先级队列：任务带优先级，紧急任务先执行。适合部分调度场景。

我自己的经验是：有界队列是最稳妥的选择。容量设置通常按“CPU核心数 × (1 + 计算等待比例)”来估算，但最可靠还是通过压测决定。你把线程池的队列容量设成无界，线上一个突发流量进来，直接内存溢出，这是我在公司真实遇到过的案例。

4.3 消息队列和阻塞队列的关系

热搜里“消息队列重复消费问题”也是高频问题。这里要分清：分布式消息队列（如RabbitMQ、Kafka）和线程间阻塞队列是两回事。前者跨进程、跨机器，后者在单进程内。

但“重复消费”问题其实阻塞队列也会遇到：消费者从队列拿任务，处理过程中崩溃或超时，任务可能被重新放回队列，导致重复执行。解决办法通常需要引入“至少一次消费 + 幂等处理”的架构。也就是说，处理逻辑必须能容忍同一条消息执行两次没有副作用。这是工程级队列应用的必备思维。

5. 队列栈与经典算法题的实战结合

5.1 BFS：队列最经典的舞台

广度优先搜索（BFS）直接对应队列的FIFO特性。从起点出发，逐层向外扩展，先遇到的一定是距离最近的路径。典型场景：迷宫最短路径、二叉树的层序遍历、社交网络好友推荐。

看一个二叉树层序遍历的代码示例：

vector<vector<int>> levelOrder(TreeNode* root) { vector<vector<int>> result; if (!root) return result; queue<TreeNode*> q; q.push(root); while (!q.empty()) { int size = q.size(); vector<int> level; for (int i = 0; i < size; ++i) { TreeNode* node = q.front(); q.pop(); level.push_back(node->val); if (node->left) q.push(node->left); if (node->right) q.push(node->right); } result.push_back(level); } return result; }

这里有个关键技巧：在循环开头用q.size()固化每层的节点数。因为你在遍历过程中还会往队列里push新节点，如果直接用while(!q.empty())，就分不清层次了。先记录size，再只处理size个节点，刚好一层的节点全部处理完，下一层的节点正好全部等在队列里。

这个模式在BFS题目里出现频率极高，务必背到肌肉记忆。

5.2 用栈实现队列，用队列实现栈：换汤不换药

力扣经典题目“用栈实现队列”（232题），考察的就是对两种结构特性的反向理解。

两个栈可以模拟一个队列：一个栈作为输入栈，一个栈作为输出栈。

class MyQueue { private: std::stack<int> inStack; std::stack<int> outStack; void transfer() { // 把输入栈的所有元素倒入输出栈 while (!inStack.empty()) { outStack.push(inStack.top()); inStack.pop(); } } public: void push(int x) { inStack.push(x); } int pop() { if (outStack.empty()) transfer(); int val = outStack.top(); outStack.pop(); return val; } bool empty() { return inStack.empty() && outStack.empty(); } };

原理：入队直接压入inStack；出队时，先检查outStack是否为空。两次入栈倒腾后，顺序就反过来了，LIFO变FIFO。这个实现的核心是“只在出队时转移，并且直到输出栈空了才转移”，保证整体摊还复杂度O(1)。

反过来的“用队列实现栈”（225题）也很有意思：用一个队列，入栈时直接把元素push到队尾，然后前n-1个元素依次出队再入队，把队尾元素转圈挪到队头。模拟一下就懂了。

这类题目表面上是“实现题”，实际上是让你理解数据结构的本质属性，考的是“你在设计接口时如何保留正确的语义”。

5.3 括号匹配与表达式求值：栈的现场教学

括号匹配是栈应用的最小经典题。理解“最近匹配优先级”是关键：

bool isValid(string s) { stack<char> st; for (char c : s) { if (c == '(' || c == '[' || c == '{') { st.push(c); } else { if (st.empty()) return false; char top = st.top(); if ((top == '(' && c == ')') || (top == '[' && c == ']') || (top == '{' && c == '}')) { st.pop(); } else { return false; } } } return st.empty(); }

这个逻辑里最容易被忽略的是两个边界条件：一是在遇到右括号时栈是空的，说明右括号没有配备对的左括号；二是整个字符串遍历结束后栈不为空，说明有左括号没被匹配。很多人只写着右括号比较，忘了最后的st.empty()判断，结果“([)]”这类用例直接漏掉。

表达式求值（中缀转后缀、后缀求值）也是栈的经典应用。中缀表达式比如3 + 4 * 2转成后缀3 4 2 * +，再拿栈扫描后缀表达式：遇到数字压栈，遇到操作符弹出两个数字计算再压回结果。这套流程理解了以后，你会发现编译器解析表达式的底层机制不过如此。

5.4 暴力枚举与剪枝：栈和队列也能给算法加速

热搜词里“暴力枚举算法”和“剪枝算法”放一起很有意思。暴力枚举是算法的最笨解法，剪枝是对枚举的优化。那么队列和栈怎么参与？

举个实际例子，全排列的DFS（深度优先搜索）可以用栈模拟递归层次，同时利用“元素是否已使用”来做剪枝。经典的N皇后问题，每一层决策都对应一个栈帧状态，用栈记录当前路径和剩余可选位置。出栈即回溯，剪枝就是提前排除不可行的分支。

用栈模拟递归的过程，本质就是把系统栈帧搬到自己控制的内存里来，可以灵活管理状态、提前剪枝、超深度遍历也不会爆栈。这在高性能计算和大规模深度搜索中非常常见。

数据结构就是这么神奇：两种最基本的线性容器，用好了可以模拟出整棵搜索数、整张图的遍历序、整个系统的运行轨迹。

5.5 KMP算法为什么也要提栈？

KMP算法本身是字符串匹配算法，核心是next数组的构建，和栈没有直接关系。但在求解next数组时，本质上也是用到了“前缀=后缀”的递推匹配思路，这种局部状态的管理方式与栈的回退很相似。很多C++教材在讲KMP时，会先讲栈的回溯性质，帮助理解“失配后指针回退”的过程。

如果追根溯源，KMP本身就是对暴力匹配的优化：暴力匹配在失配时把模式串整体右移一位，KMP利用已匹配部分的前后缀信息，让模式串一次性跳过尽可能多的距离。这个“跳过”的决策，跟单调栈里“弹出不再有用的元素”是非常像的思维模式。理解数据结构中的状态保存和状态丢弃，对你掌握任何算法都有帮助。

6. 常见问题与容易踩的坑

6.1 队列栈相关的典型报错与调试

根据我多年的经验，队列栈相关的bug主要集中在几个方面。

第一是队列栈越界。数组实现的队列栈，最容易出现front或top指针越过边界。比如循环队列中，很多人忘了取模操作，或者取模时是用front++而不是front=(front+1)%capacity，导致队列“绕圈”失败。排查方法很简单：在入队出队前后打印front、rear、length三个值，看是否始终在[0, capacity-1]区间。

第二是内存泄漏。链表实现的队列栈，节点用new分配，如果出队时忘了delete，或者析构函数没有遍历释放所有节点，就会内存泄漏。用valgrind很容易检测出来。建议养成"每个new都对应一个delete"的习惯，析构函数里用循环释放所有节点。

第三是条件变量假死。自制阻塞队列时，如果push异常路径没通知notEmpty，或者pop异常路径没通知notFull，线程就会永久卡死。排查时在wait前后分别打印线程ID和队列长度，能快速定位是谁没发信号。

6.2 面试题速查表

我自己整理了一张脱敏的面试高频题清单，供你自查：

我在给候选人出这些题目时，最看重的是“你能不能画出来”——能不能把每步的栈/队列状态画出来。能画出来，说明你真的懂了内部机制；只看代码背过，遇到变形题立刻露馅。

6.3 关于C++环境配置的一个实用提醒

热搜词里有“microsoft visual c++ 2015-2022 redistributable (x64) 下载”和“vscode配置c/c++环境”，说明很多人卡在了跑不起来代码这一步。

Windows下用VS Code跑C++，核心配置其实是三件套：编译器（MinGW-w64或MSVC）、c_cpp_properties.json（配置编译器路径和语言标准）、tasks.json（配置编译任务）。

我第一次配置时也折腾了很久，后来发现一个省事的思路：直接用Visual Studio Community版写C++，虽然启动慢一点，但环境预装完整，学数据结构和算法完全够用。如果一定要用VS Code，记得先安装C/C++扩展（Microsoft官方那个），再配置好编译器路径，否则代码里的头文件全都会标红。

另外，很多需要execinfo.h的函数在Windows MSVC环境下没有替代，只能切到Linux/WSL下实验。我建议学数据结构时尽量在Linux环境或WSL下跑，对后面理解内存布局、栈空间、崩溃回溯都更有帮助。

6.4 学习节奏建议

数据结构与算法这门课，最忌讳“眼高手低”——看例题都会，动笔全忘。我的建议是：

• 每个结构实现两遍：数组版和链表版，写完后删除重写。
• 每个算法题先画状态转移图，再写代码。
• 每学一个结构，去LeetCode搜对应题目做5道，比如学完队列做层序遍历、设计循环队列、任务调度器。
• 期末复习时把数据结构408考点（比如图、数组、栈和队列）做成一张脑图，把每个结构的操作复杂度、适用场景、典型题目列出来。

网上“数据结构实验报告”相关的热搜说明很多人在抄实验模板，我特别想说：实验报告自己写才有意义，尤其是循环队列的length变量推导、栈回溯的调用链打印，这些内容手写一遍，比看十遍答案都管用。

7. 从面试到工程：最后再给你一点经验

写到这里，我已经把队列和栈从底层原理到高级应用、从手写实现到并发陷阱完整过了一遍。最后分享几个我这些年实际工作中沉淀下来的体会。

第一，遇到任何看起来复杂的系统问题，先想想能不能用队列或栈拆解。比如数据同步顺序问题用队列、函数调用链路问题用栈、深度优先遍历用栈、广度优先遍历用队列，这个习惯能让你在系统设计道路上少走很多弯路。

第二，自己动手实现阻塞队列这个练习，比你看十篇线程池原理文章都值得。它把锁、条件变量、生产者消费者模型、队列数据结构全部串起来，是C++后端岗位面试最常考的综合性题目。我第一次完整实现时花了将近一晚上，调试虚假唤醒又花了一晚上，但从此对并发队列的理解完全不一样了。

第三，刷题别贪多，尤其是栈和队列这种基础结构，吃透三五道核心题，变形题自然会做。我见过太多人把接雨水背得很熟，结果面试官改成“下一个更大元素”就傻眼——根本没理解单调栈的核心是“淘汰掉已经毫无用处的候选元素”。

如果你是在校学生，建议把队列栈实验里最难的部分——比如循环队列的满空判断推导、用两个栈模拟队列的复杂度证明——写在实验报告的问题分析里。这比网上找模板复制粘贴有价值得多，也能帮你真正建立数据结构的底层直觉。

数据结构不是背出来的，是“画出来、写出来、调出来”的。把这篇文章里的代码都亲手敲一遍，尤其注意循环队列的取模细节、单调栈的弹出时机、阻塞队列的条件变量用法，我相信你对队列和栈的掌握程度会超过绝大多数同行。