佚格麻瓜代码随想录算法训练营进行到第十天，题目依次是232.用栈实现队列、225.用队列实现栈、20.有效的括号、1047.删除字符串中的所有相邻重复项。单看难度，这四道题不算狠，代码量也很小，但如果你跟着训练营一路刷过来，应该能感觉到这组题和前面数组、链表、哈希表的刷法不太一样——前两题是在用数据结构“造”另一个数据结构，后两题才是栈在具体场景里的直接应用。我见过不少同学抄完题解就算过，过两周再写232还是会卡在“什么时候把in栈的数据倒进out栈”这个细节上。
如果你也想彻底把这一组题吃透，我建议停下来认真复盘一次。文章不会只贴四个AC代码，而是重点解释每一题为什么这样设计、哪个细节最容易想当然、以及我在实际刷题中踩过和见别人反复踩的坑。这样等你自己遇到“栈和队列互相实现”的变形题时，才不会只是背模板。
1. 这四道题放在同一天，练的其实是同一个东西
1.1 为什么训练营要把“互相模拟”和“栈的应用”混在一起排
很多人拿到第十天的任务单，第一反应是：232和225是镜像题，20和1047又是独立的重复题，四道题放一起有点乱。其实编排逻辑很清晰。
前两道题考的是“容器语义模拟”，也就是你不能直接用现成的队列，却要用栈这种完全不同语义的结构来实现队列；或者反过来，用队列实现栈。后两道题考的是“栈的使用场景”，一类是括号匹配，一类是相邻重复项消除，它们不要求你自己实现新容器，而是把栈当作解题工具用进去。
如果拆开看，第一二题解决的是“栈和队列到底是什么”，第三四题解决的是“栈这个东西什么时候好用”。放到同一天，就是先让你把两种容器的行为差异彻底想明白，再让你用一个真实的算法题验证这种差异。所以我始终觉得，训练营把这几题安排在一起并不是随意拼凑，而是一套完整的“理解结构-封装结构-应用结构”的小闭环。
1.2 判断直觉：数据结构的作用是约束访问顺序
要真正做对这几道题，先建立一条最底层的直觉：栈和队列的差别，本质上是访问顺序的差别。
栈是后进先出（LIFO），你最后放进去的元素总是最先被取走；队列是先进先出（FIFO），谁先来谁先被处理。用生活场景类比的话，栈就像一摞盘子，你永远只能拿到最上面那个；队列就像食堂排队，前面的人打完饭离开了，后面的人才能往前挪。
这个差别听起来太基础了，但很多人做题时没有把它落到代码判断上。比如232题，看到题目后脑子里想的不是“我要让后进先出变成先进先出”，而是直接去背两个栈、一个负责入、一个负责出的模板。一旦题目换一个马甲，比如允许你用两个队列实现一个带最大值功能的栈，立刻就垮了。所以这一章先把访问顺序作为主语，后面四道题的代码才能被串起来理解。
1.3 四道题内部的递进关系
这一天的题目并不是简单并列，它们之间有明显的递进关系：
- 20和1047其实是最低层“栈的直接应用”：一个需要保存左括号顺序，一个需要保存当前已经处理的结果前缀，两者都用到了“栈顶就是最近状态”这个特性。
- 232是更高一层“栈的抽象应用”：光会用栈还不够，你得用两个具有相反方向栈的结构组合出队列的顺序。
- 225又是反向的抽象应用：你得把队列的“队尾”想法设法搬到“队头”，以匹配栈顶语义。
也就是说，如果你先把20和1047写顺了，对“栈顶”有感觉，再去做232、225，思路会一下子打开。下面的章节我就按这个递进顺序逐个拆。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 232.用栈实现队列：只有当out栈空了才能“整体倒灌”
2.1 先想清楚：单靠一个栈为什么做不到先进先出
先做个最简单的实验。向一个栈里依次push 1、2、3，栈底到栈顶依次是1、2、3。栈的pop操作只会把3弹出来，返回顺序是3、2、1。可是队列要求第一次pop得到1。
也就是说，只用单个栈，我们看到的永远是最晚进来的元素，完全和队列相反。
有一种处理办法：入队时先把已有元素全部挪到临时结构，把新元素塞到底部，再把旧元素搬回来。但题目要求只能用栈的标准操作，没有额外数组，那最好的“临时结构”就是另一个栈。一个栈负责接收新入队的元素，另一个栈负责把元素顺序再反转一次。因为一个栈让元素逆序，两层栈叠在一起，整个序列就被反转两次，回到原来的顺序。这就是双栈模拟队列最核心的原理。
2.2 双栈结构各管一头：代码实现
我们把两个栈分别命名为inStack和outStack。职责边界非常清楚：
- inStack只处理“入队”操作，push时直接压进去。
- outStack只处理“出队”操作，pop或peek时优先用outStack顶部。
- 当outStack为空的时候，把inStack里的所有元素一次性倒进outStack。
下面是我最终提交的写法：
cpp复制class MyQueue {
private:
stack<int> inStack;
stack<int> outStack;
void transferIfNeeded() {
// 只有 out 为空时才倒，保证元素顺序一次到位
if (!outStack.empty()) return;
while (!inStack.empty()) {
outStack.push(inStack.top());
inStack.pop();
}
}
public:
void push(int x) {
inStack.push(x);
}
int pop() {
transferIfNeeded();
int res = outStack.top();
outStack.pop();
return res;
}
int peek() {
transferIfNeeded();
return outStack.top();
}
bool empty() {
return inStack.empty() && outStack.empty();
}
};
代码里唯一需要注意的地方就是private里的transferIfNeeded()。它的作用不是每次pop都执行搬运，而是在outStack被取空之后才搬运。
来看一个完整的执行过程你会更清楚。连续执行push(1)、push(2)、push(3)之后，inStack栈底到栈顶是1、2、3，outStack为空。第一次执行pop()，transferIfNeeded()会执行：把3弹出压入outStack，再把2压入，再把1压入，此时outStack栈顶是1，正好是队首。pop()返回1，同时outStack里还剩2、3，栈顶为2。
紧接着执行push(4)，4只进入inStack。此时理论上的队列顺序是2、3、4，下一次pop应该返回2。因为outStack中还有2、3，非空，transferIfNeeded()不会执行，pop()直接取outStack栈顶返回2，完美命中。继续pop，又返回3，等outStack空了，再进行下一次倒数据。这种设计保证每个元素从inStack到outStack最多被搬运一次，整体平均复杂度接近O(1)。
2.3 outStack判空是整个题的“阀门”，也是最大的翻车点
232这道题真正的考点，不是“会不会用两个栈”，而是能不能正确控制什么时候倒数据。
我见过很多初学者第一次写这题，会写成每次push时都把inStack里的元素搬到outStack，或者每次pop时先把outStack清空再重新倒一遍。这样表面也能跑通，但性能会退化成O(n)甚至更差，而且代码分支一多，顺序就很容易错乱。
更隐蔽的坑在peek()。很多人写完pop()之后，懒得再写一遍搬运逻辑，就在peek()里直接调用pop()拿结果再压回去。这种做法不算错，但要小心如果一个类以后状态复杂了，很容易在“把值压回哪个栈”这个问题上出错。我个人的习惯是单独实现一个transferIfNeeded()，让pop和peek都复用它，职责单一。
另一个小坑是empty()。如果你只判断inStack.empty()，当元素已经被搬到outStack中时，你会误判队列为空。正确的判断必须是两个栈都为空。这点代码只有一行，但面试时很常被追问。
3. 225.用队列实现栈：让新元素站到队头
3.1 为什么这道题比232更容易让人懵
232的逻辑其实很顺：两个反方向的栈一叠加，逆序两次就回到正序。225则更反直觉，因为队列只允许从队尾进入、从队头离开，顺序非常固定，想让它模拟出“后进先出”的栈，不能靠简单反转一次解决。
换个角度想：栈顶是谁？是最近push进去的元素。队列队头是谁？是最早push进去的元素。所以只要让每个新push的元素想办法插到队头，那么从队头pop出去时，它就是后进先出的那个元素。
具体怎么做？最简单的办法是：每次push一个新元素时，先把它放到队尾，然后把它前面的所有旧元素依次从队头取出、重新追加到队尾。相当于让新元素插队到最前面，其他元素顺序不变地排在它后面。一个queue就够完成这个操作，这也是官方题解中最精简的版本。
3.2 两个队列版本：每次入栈都“整理”成队列头即栈顶
先看两个队列的写法。很多人以为两个队列是“一个主队列、一个备份队列，pop时把前面的元素搬到备份里”，那种写法也能过。但这里我推荐一种更好理解、也不需要swap两次的写法：
cpp复制class MyStack {
private:
queue<int> q1;
queue<int> q2;
public:
void push(int x) {
// q2 作为中转，先接收新元素
q2.push(x);
// 把 q1 之前所有元素挪到 q2，保证新元素在队头
while (!q1.empty()) {
q2.push(q1.front());
q1.pop();
}
// q2 变成主队列，q1 变成空的中转队列
swap(q1, q2);
}
int pop() {
int res = q1.front();
q1.pop();
return res;
}
int top() {
return q1.front();
}
bool empty() {
return q1.empty();
}
};
这个实现的关键是每次push结束后立刻做一次整理，保证q1的队头永远等于当前栈顶。q2是一个中转站，整理完之后必须为空，因为下一次push还要继续复用。一定不要忘记最后的swap，否则老队列里的数据会残留下来。
3.3 一个队列的优化版：把旧元素绕到新元素后面
两个队列版本可以进一步精简成一个队列。
cpp复制class MyStack {
private:
queue<int> q;
public:
void push(int x) {
int size = q.size();
q.push(x);
// 把前面的 size 个元素依次取出，追加到队列尾部
while (size--) {
int tmp = q.front();
q.pop();
q.push(tmp);
}
}
int pop() {
int res = q.front();
q.pop();
return res;
}
int top() {
return q.front();
}
bool empty() {
return q.empty();
}
};
这个方法的核心在push函数：新元素先入队放到队尾，此时队列长度为size+1。前面有size个旧元素，把队头的旧元素一个接一个弹出再重新入队，每个元素都绕到新元素后面，新元素自然就变成队头了。
举个例子，假设连续push 1、2、3，队列变化过程是这样的：
- 初始队列为空，push 1后队列为[1]，队头是1。
- push 2：队列变为[1,2]，size=1，执行一次旋转后队列变为[2,1]，队头是2。
- push 3：队列变为[2,1,3]，size=2，先弹出2追加到尾部，队列变成[1,3,2]；再弹出1追加到尾部，队列变成[3,2,1]，队头是3。
这时pop()弹出的元素是3，和栈的行为完全一致。
3.4 双队列和单队列版本的复杂度对比
把两个版本放在一起，能更清楚看出它们其实是同一种思想：
| 实现方式 | push复杂度 | pop/top复杂度 | 空间复杂度 | 核心思路 |
|---|---|---|---|---|
| 两个队列版 | O(n)，每push都要旋转旧元素 | O(1) | O(n) | 中转队列接收新元素，旧元素全部挪到它后面，再交换 |
| 一个队列版 | O(n)，每push要size次旋转 | O(1) | O(n) | 直接在同一条队列里把旧元素绕到新元素后面 |
为什么push是O(n)而pop却是O(1)？因为所有代价都提前花在了“整理顺序”上。如果把“整理”推迟到pop阶段，就会变成push是O(1)、pop是O(n)，两种方案在题目要求下都能通过，面试时你可以按自己的习惯选择，但一定要能说清楚自己的代价发生在哪个阶段。
另外要特别提醒一个坑：在单队列版本里，push循环次数必须提前用size保存下来。如果你直接在循环里写q.size()，因为q.size()会随队列操作动态变化，循环次数会多出很多，最终队列顺序彻底错乱。
4. 20.有效的括号：把错误情况拆成三种，比背代码有用
4.1 括号嵌套天然就是“后进先出”
遇到一个左括号时，你无法立刻判断它是否匹配，只能先记住它；等遇到右括号时，需要匹配的是最近出现的那个左括号。这个“最近出现”的顺序，就是栈的典型出场场景。
比如字符串是({[]})，扫描到(入栈，扫描到{入栈，扫描到[入栈，然后遇到]时栈顶正好是[，匹配成功，弹出；再遇到}时栈顶恰好是{，匹配成功。整个流程就像剥洋葱，从最内层开始往外匹配。
这道题如果只统计左括号和右括号的数量，会掉进一个经典陷阱。比如字符串([)]，左括号数量是两个，右括号数量也是两个，数量完全相等，但实际括号顺序是错的：[还没闭合就遇到了)。只有用栈记录“当前最需要被匹配的字符是谁”，才能判断这种交叉嵌套的错误。
4.2 三种失败形态分别出现在哪里
有效的括号本质上只有一个合法路径：每个右括号到来时，栈里得有一个正好匹配的左括号；扫描结束后，栈里不能再剩任何左括号。因此所有非法情况都可以归成三类：
- 右括号多于左括号：比如
()]}，扫描到)匹配成功，后面遇到]时栈已经空了，说明这个右括号没有对应的左括号。 - 左括号多于右括号：比如
(()，扫描结束之后栈里还剩一个(，说明缺少右括号。 - 左右括号数量一样但类型不匹配：比如
(]，扫描到]时栈顶是(，不是[，括号类型对不上。
写代码时，把这三类情况对应成清晰的if分支，比死记硬背一个判断模板要牢固得多。
4.3 用“压入期望字符”简化实现
常规写法是遇到左括号时把左括号本身压栈，等到遇到右括号时再把栈顶左括号取出来做if-else匹配。这种写法逻辑没问题，但会多