清浅池塘先交代一下背景，这四道题是“代码随想录算法训练营”第十天的内容，也是 LeetCode 上非常经典的高频面试题。很多人在学习栈和队列的时候，总觉得这俩结构太简单：一个先进后出，一个先进先出，背一遍概念就完事了。但真到了刷题、面试，遇到“用栈实现队列”“用队列实现栈”这种互相模拟的题，立刻就被绕晕了。这四道题正好把栈和队列的特性、操作顺序、边界条件全部串了起来，刷完之后你会有一种“哦，原来栈和队列还能这么玩”的豁然开朗感。这篇文章，我把这四道题的完整思路、代码实现、易错点、面试追问全部整理出来，适合正在准备算法面试、或者刚入门数据结构想打牢基础的朋友。
1. 为什么训练营把栈和队列放在同一天练
1.1 栈和队列的本质是一对“反着来”的兄弟
栈是先进后出（LIFO），队列是先进先出（FIFO），这两者看着简单，但放在一起对比着学，效果远好于逐个学。原因很简单：栈和队列的操作逻辑互为镜像。栈的入栈、出栈是对同一端操作，队列的入队、出队是两端各管各的。你如果只背“栈是进进出出同一个口”，很快就忘了；但如果你亲手用两个栈去模拟队列，你会深刻地记住“栈的反向输出就是队列”，这种由实操带来的记忆，比背十遍定义都管用。
训练营第十天的题目编排也很有讲究，不是随便挑了四道题。232 和 225 是“互相模拟”，直接考察你对这两种数据结构的底层理解；20 和 1047 是“栈的应用”，考察你在具体场景里能不能想到用栈来解决问题。这四道题一起刷，既锻炼了数据结构的基础认知，又锻炼了“识别题型→匹配数据结构→写出代码”的实战能力，可以说是一次非常典型的“数据结构专题训练”。
1.2 四道题的递进关系：从模拟到应用
我刷完这四道题之后，最大的感觉是难度是螺旋上升的。232 和 225 虽然名字听着吓人“用栈实现队列”，但本质上只是“操作顺序的排列组合”，只要你理解两个栈倒来倒去的逻辑，其实不难。20 有效的括号就开始有一点“题目包装”了，它不直接说“用栈”，而是要你自己从括号嵌套的场景里抽象出“后遇到的左括号先匹配”这个规律，这本质上就是栈的特性。1047 删除字符串中的所有相邻重复项更进一层，它不仅要求你用栈，还要求你想到“双指针原地操作”这种空间复杂度更优的方案。
所以这四道题的正确刷法，不是一道一道孤立地刷，而是把它们当成一个整体：先在草稿纸上画清楚“栈和队列互转”的状态变化，再去做括号匹配、相邻重复项删除这些应用类的题目。你会发现自己对栈和队列的直觉，在训练营这十天里又上了一个台阶。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 232. 用栈实现队列：两个栈的默契配合
2.1 核心思路：把后进先出变成先进先出
用栈实现队列的难点在于：队列要求先进先出，但栈只能后进先出。怎么解决？答案是准备两个栈，一个负责“进”，一个负责“出”。
我用一个最直白的例子来说明：想象你有两个杯子并排放在桌上，左边的杯子叫 stackIn，右边的杯子叫 stackOut。入队的时候，你把元素一个一个丢进左边的杯子（就是入栈），比如依次丢入 1、2、3，那么从左边杯口往里面看，从上到下依次是 3、2、1。
出队的时候，你不能直接从左边杯子拿，因为你要拿的是最先进来的 1，它在最底下。这时候把左边杯子里所有元素一个一个倒进右边杯子：先把 3 倒进右边，再把 2 倒进右边，最后把 1 倒进右边。倒完之后，右边杯子从上到下依次是 1、2、3。这时从右边杯子顶部拿一个，拿到的就是 1，完美实现了先进先出。
这个过程中最关键的一步，就是“把 stackIn 的元素全部倒入 stackOut”这个动作，我习惯把它叫做“倒水”。不是每次出队都要倒，只有在 stackOut 为空的时候才需要倒。这个判断条件非常重要，如果写错了，顺序就会乱。
2.2 代码实现与关键细节
我用 Java 来写，队列的题我用 ArrayDeque 当栈用，注意 Java 里 Stack 类虽然也能用，但它继承了 Vector，有同步锁的开销，刷题和工作中更推荐 ArrayDeque。代码如下：
java复制class MyQueue {
// 负责入队的栈
Deque<Integer> stackIn;
// 负责出队的栈
Deque<Integer> stackOut;
public MyQueue() {
stackIn = new ArrayDeque<>();
stackOut = new ArrayDeque<>();
}
// 入队：直接压入 stackIn
public void push(int x) {
stackIn.push(x);
}
// 出队：如果 stackOut 为空，先把 stackIn 全部倒过来
public int pop() {
if (stackOut.isEmpty()) {
while (!stackIn.isEmpty()) {
stackOut.push(stackIn.pop());
}
}
return stackOut.pop();
}
// 获取队首元素：逻辑和 pop 一样，只是不弹出
public int peek() {
if (stackOut.isEmpty()) {
while (!stackIn.isEmpty()) {
stackOut.push(stackIn.pop());
}
}
return stackOut.peek();
}
// 两个栈都为空，队列才为空
public boolean empty() {
return stackIn.isEmpty() && stackOut.isEmpty();
}
}
这里有一个非常容易踩的坑：peek 和 pop 里“倒水”的逻辑是一样的，很多人会写两遍倒水的代码，虽然能过，但不优雅。其实可以让 peek 调用 pop，先取出队首元素，再重新压回去，或者写成单独一个方法。我在实际刷题的时候，喜欢把“倒水”逻辑抽出来作为一个私有方法，这样代码更清晰。
另一个细节是：倒水动作必须是“一次性全部倒完”。有些人会想，我能不能在 stackOut 里剩一个元素的时候就开始倒新的？不行，那样顺序就乱了。举个例子：stackIn 里有 1、2、3，你只倒了 3、2 到 stackOut，然后新的 4 又进 stackIn，这时 stackOut 里是 3、2，队首是 2，但实际队列顺序应该是 1、2、3、4，队首明明是 1。所以必须保证“stackOut 为空时，stackIn 全部倒过来”，中间不能打断。
2.3 复杂度分析与面试追问
时间复杂度方面，push 是 O(1)，pop 是均摊 O(1)。为什么是均摊？因为每个元素最多只会被“倒”两次：一次从 stackIn 弹出压入 stackOut，一次从 stackOut 弹出返回。所以整体来看，n 次操作的总时间复杂度是 O(n)，平均到每次就是 O(1)。
面试官拿到这道题，最常见的追问有两个。第一：“能不能用一个栈实现队列？”答案是做不到，因为单一栈只能在同一端操作，无法改变元素顺序。第二：“如果连续 pop 几次，中间穿插 push，队列顺序会不会乱？”答案是不会，只要你严格遵守“stackOut 为空才倒水”的规则。
我还想补充一个进阶思路：这道题的 Java 版本里，很多人用 Deque<Integer> stack = new LinkedList<>() 来当栈，其实更推荐 ArrayDeque，因为 LinkedList 涉及节点对象的创建和指针维护，常数较大。虽然 LeetCode 上差距不明显，但养成好习惯总是没错的。
3. 225. 用队列实现栈：换个角度，同样精彩
3.1 两个队列的核心思路：入栈时调整顺序
用队列实现栈，思路和上一题完全不同。队列是先进先出，我们要把它变成后进先出，就需要在“入栈”这个环节就动手脚，让后进来的元素排在队首。这样出栈的时候直接弹出队首就可以了。
用两个队列 queue1 和 queue2，我习惯把 queue1 当作“主栈”，queue2 当作“辅助栈”。入栈的时候，先把新元素放进 queue2，然后把 queue1 里的所有元素依次出队并放入 queue2。此时 queue2 的顺序就是“新元素在队首”，然后把两个队列互换一下引用，queue2 变成新的主队列。这个过程相当于把新元素“插队”到了最前面。
文字描述有点抽象，我画个示意图。假设当前 queue1 里从队首到队尾依次是 2、1，表示栈顶是 2。现在要压入 3：
- 先把 3 放入 queue2，queue2：3
- 把 queue1 里的 2、1 依次弹出，放入 queue2，queue2：3、2、1
- 交换 queue1 和 queue2，queue1：3、2、1，queue2：空
此时 queue1 的队首是 3，正好是最后入栈的元素。出栈时直接弹出队首即可。
3.2 两个队列的代码实现
java复制class MyStack {
Queue<Integer> queue1;
Queue<Integer> queue2;
public MyStack() {
queue1 = new LinkedList<>();
queue2 = new LinkedList<>();
}
// 入栈：新元素先进辅助队列，然后主队列所有元素迁移过来
public void push(int x) {
queue2.offer(x);
while (!queue1.isEmpty()) {
queue2.offer(queue1.poll());
}
// 交换引用
Queue<Integer> temp = queue1;
queue1 = queue2;
queue2 = temp;
}
// 出栈：直接弹出主队列队首
public int pop() {
return queue1.poll();
}
// 获取栈顶元素
public int top() {
return queue1.peek();
}
public boolean empty() {
return queue1.isEmpty();
}
}
这个实现里，入栈是 O(n)，出栈是 O(1)。注意 queue2.offer(x) 之后，queue2 可能不是空的？不会，因为每次操作完我们都会交换引用，queue2 被清空了，所以新元素入队时 queue2 一定是空的。
有人会问，能不能交换的顺序反过来，写成“先把 queue1 的元素移到 queue2，再把新元素放入 queue2”？可以的，但要注意最终哪个队列为主队列，逻辑一样，只是写法不同。我推荐的这种“先放新元素，再迁移旧元素”的方法，队列顺序更好理解。
3.3 一个队列的精妙写法
既然是“用队列实现栈”，有的面试官会追问：能不能用一个队列实现？答案是可以，还更简单。核心思路是：每次入栈时，先把新元素入队，然后把队列前面的旧元素依次出队再重新入队，这样新元素就到了队首。整个过程不需要辅助队列，直接在原队列上“旋转”。
举个例子，队列目前从队首到队尾是 2、1，代表栈顶是 2。要压入 3：
- 先把 3 入队：2、1、3
- 把 2 出队再入队：1、3、2
- 把 1 出队再入队：3、2、1
此时队首就是 3，完美。代码如下：
java复制class MyStack {
Queue<Integer> queue = new LinkedList<>();
public void push(int x) {
int size = queue.size();
queue.offer(x);
// 把前面的元素依次移到后面
for (int i = 0; i < size; i++) {
queue.offer(queue.poll());
}
}
public int pop() {
return queue.poll();
}
public int top() {
return queue.peek();
}
public boolean empty() {
return queue.isEmpty();
}
}
这段代码非常优雅，空间复杂度也比两个队列的写法更低。我强烈建议把这种写法也记下来，面试的时候主动提出来，会比只写两个队列的版本更能展示你对队列操作的深入理解。
3.4 两题对比：模拟方向不同，操作时机不同
232 用栈实现队列，关键操作在出队时“倒水”；225 用队列实现栈，关键操作在入栈时“旋转”。为什么会相反？因为栈和队列的核心矛盾不同：栈是后进先出，队列是先进先出。用栈模拟队列，难点在于“队首在最底下”，所以要在出队时把顺序反过来；用队列模拟栈，难点在于“栈顶在队尾”，所以要在入队时把新元素移到队首。
这给了我一个启发：做这类“互相模拟”的题，不要一上来就背代码，而是先画一个操作序列，比如入 1、入 2、出队、入 3、出队，然后一步步跟踪每个数据结构的状态变化。等你把状态变化搞清楚了，代码自然就能写出来。这也正是训练营第十天的核心训练目标：从操作顺序入手理解数据结构。
4. 20. 有效的括号：栈的“实战演习场”
4.1 题目分析：三种不匹配的情况
给定一个只包含 ( ) { } [ ] 的字符串，判断括号是否有效。有效的定义是：左括号必须用相同类型的右括号闭合，左括号必须以正确的顺序闭合。例如 ()[]{} 有效，([)] 无效，(] 无效。
我第一次看到这个题的时候觉得很简单：不就是括号配对嘛，数一数左括号和右括号的数量相等不就行了？但 ([)] 这种反例立刻否定了这种想法。正确的要求是“顺序匹配”，也就是最近出现的左括号，必须最先被匹配。这恰恰是栈的特性：后进先出。遍历字符串时，遇到左括号就压栈，遇到右括号就弹出栈顶，检查是否匹配。
代码随想录里把不匹配的情况总结为三种，我觉得非常精辟：
- 字符串遍历完了，栈里还有多余的左括号，比如
(()。这种是左括号多余。 - 弹出栈顶时，栈顶和当前右括号不匹配，比如
(]。这种是括号类型不匹配。 - 遇到右括号时，栈已经空了，比如
())。这种是右括号多余。
三种情况的处理方式不同，但有一个非常优雅的统一写法：遇见左括号时，不要直接压入左括号本身，而是压入它对应的右括号。这样在遇见右括号时，只需要比较栈顶是否等于当前字符即可，代码会简洁很多。这也是卡哥反复强调的一个小技巧。
4.2 Java 代码实现与剪枝
java复制class Solution {
public boolean isValid(String s) {
// 剪枝：奇数长度直接排除
if (s.length() % 2 == 1) {
return false;
}
Deque<Character> stack = new ArrayDeque<>();
for (char c : s.toCharArray()) {
if (c == '(') {
stack.push(')');
} else if (c == '{') {
stack.push('}');
} else if (c == '[') {
stack.push(']');
} else if (stack.isEmpty() || stack.pop() != c) {
// 栈为空说明右括号多余；栈顶不等于当前字符说明类型不匹配
return false;
}
}
// 遍历完栈还有元素，说明左括号多余
return stack.isEmpty();
}
}
这段代码有几个值得注意的细节。第一，剪枝操作 s.length() % 2 == 1 直接返回 false，因为有效的括号字符串一定是偶数长度，这个优化虽然简单，但在长字符串测试用例下能节省一次完整的遍历。第二，stack.pop() != c 这里用的是 char 基本类型比较，所以可以用 !=，如果栈里存的是 Character 包装类型，就要注意用 !stack.pop().equals(c)，否则会踩到引用比较的坑。第三，把左括号对应的右括号压栈，省去了复杂的 if-else 匹配逻辑，可读性非常高。
这个“压入对应右括号”的技巧，在之后很多括号相关的题目里都能用，比如括号的生成、括号的移除等，值得彻底掌握。
4.3 面试延伸：栈在括号匹配之外的场景
这道题虽然简单，但它代表了一类问题：文本中嵌套结构的合法性校验。除了括号，类似的还有 HTML 标签的匹配、代码编译时的大括号检查、正则表达式中的嵌套分组等。凡是“先出现的必须最后被匹配”的结构，都可以用栈来解决。
面试官可能会继续追问：如果字符串里只有一种括号 ()，怎么用 O(1) 空间判断？这时栈就可以用一个整数计数器替代，遇左括号加一，遇右括号减一，中途计数器为负说明右括号多余，最后计数器必须为零。这其实就是空间复杂度的优化思路，从 O(n) 降到 O(1)。但要注意，这个优化只适用于“单一种类括号”的场景，一旦括号种类变多，计数器就失效了，必须用栈。这也是面试时考察你“是否会根据条件选择合适数据结构”的典型套路。
5. 1047. 删除字符串中的所有相邻重复项：栈的“化简”能力
5.1 题目分析与栈解法
题目要求：给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。反复执行这个操作，直到无法继续删除。最后返回结果字符串。比如输入 abbaca，过程是：abbaca 删除 bb 变成 aaca，再删除 aa 变成 ca，返回 ca。
这道题的关键点在于，删除一对相邻项之后，原本不相邻的字符可能变成新的相邻重复项。比如 abba，先删除 bb，剩 aa，再删除 aa，最后为空字符串。这种“连锁反应”用暴力法每次找相邻重复项再删除，时间复杂度会达到 O(n²)，非常低效。
用栈来解决就非常自然了。遍历字符串的每个字符，如果栈不为空且栈顶字符等于当前字符，说明出现相邻重复，弹出栈顶；否则把当前字符压入栈。最终栈里剩下的字符按顺序就是结果。这个思路本质上和“20. 有效的括号”如出一辙：栈天然适合处理“相邻匹配并消除”的问题。
java复制class Solution {
public String removeDuplicates(String s) {
Deque<Character> stack = new ArrayDeque<>();
for (char c : s.toCharArray()) {
if (!stack.isEmpty() && stack.peek() == c) {
stack.pop();
} else {
stack.push(c);
}
}
// 栈里的顺序是倒的，需要反转
StringBuilder sb = new StringBuilder();
while (!stack.isEmpty()) {
sb.append(stack.pop());
}
return sb.reverse().toString();
}
}
这里要注意一点：因为栈是后进先出，所以从栈里弹出来拼接的字符串顺序是反的，最后需要 reverse() 一下。很多人在这一步吃亏，测试用例结果总是反的，然后怀疑自己的逻辑有 bug，其实只是忘了反转。这个坑我至少见五个同学踩过。
5.2 优化思路：用字符串直接当栈
既然栈只是用来存字符，最后又要拼接字符串，那完全可以用 StringBuilder 直接模拟栈。栈顶就是 StringBuilder 的最后一个字符，压栈就是 append，弹栈就是 deleteCharAt。这样省去了栈转字符串再反转的过程，时间和空间都更优。
java复制class Solution {
public String removeDuplicates(String s) {
StringBuilder sb = new StringBuilder();
for (char c : s.toCharArray()) {
if (sb.length() > 0 && sb.charAt(sb.length() - 1) == c) {
sb.deleteCharAt(sb.length() - 1);
} else {
sb.append(c);
}
}
return sb.toString();
}
}
这段代码简洁很多，而且避免了 Deque 的拆箱装箱操作。在 LeetCode 提交的时候，内存和耗时都明显优于纯栈版本，我实测大概能快 2 到 3 毫秒。虽然这点时间在判题系统里不算什么，但在面试中主动写出这种优化，是一个很好的加分项，说明你对底层实现有思考。
5.3 进阶：双指针原地修改，空间 O(1)
面试官看到你写出了 StringBuilder 版本，可能还会追问：能不能再优化到只用 O(1) 的额外空间？答案是肯定的，用双指针。思路是把原字符串转成字符数组，用一个慢指针 slow 模拟栈顶，遍历快指针 fast，如果 slow 大于 0 且 chars[slow - 1] == chars[fast]，说明出现相邻重复，slow 回退一格（相当于弹栈）；否则把 chars[fast] 写到 chars[slow] 的位置，然后 slow 前进一格。最后截取 [0, slow) 范围内的字符作为结果。
java复制class Solution {
public String removeDuplicates(String s) {
char[] chars = s.toCharArray();
int slow = 0;
for (int fast = 0; fast < chars.length; fast++) {
if (slow > 0 && chars[slow - 1] == chars[fast]) {
slow--;
} else {
chars[slow++] = chars[fast];
}
}
return new String(chars, 0, slow);
}
}
这个双指针解法的精妙之处在于：slow 指针前面的部分永远是“消除完毕”的结果，fast 指针探索新字符。slow 的回退就相当于把栈顶弹出，slow 的前进就相当于压栈。整个过程不需要额外数据结构，空间复杂度 O(1)。我刷题时第一次看到这个解法，真的有种“柳暗花明”的感觉，原来原地修改还能这样模拟栈。这个解法并不容易想到，但它背后的“快慢指针 + 原地覆盖”思想，在数组类题目中非常通用，值得深入研究。
这道题还有进一步的扩展，比如 LeetCode 1209 题 “删除字符串中的所有相邻重复项 II” 中，要求删除连续出现 k 次的字符，那就需要在栈里同时记录字符和连续次数，用数组实现“字符-次数”双栈。这也是训练营之后会遇到的题目，如果你能把 1047 吃透，那道题就只是多加一个计数维度而已。
6. 常见问题与排查技巧实录
6.1 栈和队列相关的高频面试追问
根据我刷题和面试的经历，面试官非常喜欢在这类题目的基础上做延伸提问。我整理了几个高频追问方向：
第一，问 Java 里为什么不用 Stack 类。答案：Stack 继承自 Vector，每个方法都有 synchronized 修饰，存在不必要的线程安全开销；而且 Stack 在接口设计上不够规范，比如不能用统一的 Deque 接口操作。现在官方也推荐使用 ArrayDeque 或 LinkedList 实现栈。
第二，问队列实现用 LinkedList 还是 ArrayDeque。答案是两个都可以，但要注意 ArrayDeque 不允许存储 null 元素，LinkedList 允许。在算法题里通常不会存 null，所以两者皆可；如果要频繁在头部和尾部操作，ArrayDeque 效率更高，因为它基于循环数组实现，而 LinkedList 基于链表，涉及到节点的创建和 GC。
第三，问栈有哪些经典应用场景。除了括号匹配和相邻重复项删除，还有表达式求值（中缀转后缀）、函数调用栈（递归底层机制）、浏览器的前进后退、撤销操作等。能举出这些例子，面试官会觉得你不是在背题，而是真的理解栈的用途。
6.2 刷题过程中最常见的四个坑
刷这四道题，我总结了四个学员最容易踩的坑，每一个我都亲自踩过或者看别人踩过。
第一个坑是在 232 题中，每次 pop 都把 stackIn 全部倒入 stackOut，忘了判断 stackOut 是否为空。这样会导致顺序错乱，比如先 push 1、2，pop 拿到 2，实际应该拿到 1。解决办法很简单，牢记“stackOut 为空才倒，倒就全部倒完”。
第二个坑是在 225 题中，把一个队列实现的时候，for (int i = 0; i < queue.size(); i++) 循环次数没提前存下来，导致每轮循环 queue.size() 都在变，数组越界或者移动次数不对。解决办法是先把 size 存储到局部变量，再进入循环。
第三个坑是在 20 题中，用 Character 对象直接和 char 比较时，误用了 == 而不是 equals。虽然自动拆箱有时候能救你，但为了稳妥，要么统一用基本类型，要么统一用 equals。Stack 里存储的元素类型是 Character，所以弹出后是对象，和 char 比较时 Java 会自动拆箱，实际上 pop() != c 也能跑通，但为了代码的可读性，建议在栈里就用 Deque<Character>，然后显式拆箱。
第四个坑是在 1047 题中，把 StringBuilder 当栈用的时候，最后忘了处理栈里剩余元素顺序反转的问题。如果你用纯栈版本，最后一定要 reverse()；如果用 StringBuilder 版本，就不存在这个问题。所以从代码简洁度角度看，我更推荐直接用 StringBuilder。
6.3 我的排查方法论：先画图，再调试，最后看用例
遇到这类题报错，我建议不要直接盯着代码看，效率太低。我的做法是拿一个具体的用例，在纸上画出每一步栈和队列的状态。比如 232 题报错，我就模拟 push(1), push(2), pop(), push(3), pop(), pop() 这个过程，画出每一步 stackIn 和 stackOut 的内容，很快就能定位到是“倒水时机”还是“倒水数量”的问题。
如果画图还找不到问题，再用 IDE 的调试器或者 LeetCode 的自定义测试用例，配合输出每个步骤栈的内容。实际测试下来，90% 的错误都能通过“手工模拟 + 局部输出”的方式定位。这个方法论看起来朴素，但效率非常高，尤其适合自己刷题练习的时候使用。
7. 四道题刷完，我总结出的“栈队应用”心法
刷完这四道题之后，我最大的收获不是记住了某道题的解法，而是总结出了一套应对“栈和队列”类题目的心法。首先，拿到题目先判断：这道题描述的结构是“先进先出”还是“后进先出”？判断依据是“后出现的内容是否需要先被处理”，如果是，那么大概率要用栈；如果是“先来先服务”，则考虑队列。其次，栈和队列互相模拟的题，核心不是记代码，而是理解“在哪个操作环节调整顺序”。用栈模拟队列，在出队时调整；用队列模拟栈，在入队时调整，这个规律可以推广到更复杂的模拟题。最后，能用数组、StringBuilder 等原生结构模拟栈和队列时，尽量用，因为空间和时间的常数项更低，代码也更简洁。
还有一点我想单独说：不要小看这些“数据结构入门题”。很多人觉得 20 和 1047 太简单，不值得花时间。但我在实际面试中，遇到过好几家公司把 20 题变形后作为第一道算法题，比如在字符串里同时处理括号和引号的嵌套校验。如果你对栈的应用理解不够透彻，遇到变体题就会发懵。把这四道题的价值挖掘到最大，你之后做单调栈、滑动窗口、表达式求值等更复杂的题目，都会轻松很多。
最后再分享一个小技巧：训练营刷题的时候，建议每道题都用自己的话写一篇解题笔记，不用很长，记录三个东西——核心思路、代码里最妙的那个点、踩过的坑。这四道题学完之后，我回头翻自己的笔记，只看标题就能迅速回忆起思路，很大程度上减少了重复刷题的时间。这也是我在代码随想录训练营里学到的最高效的学习方法之一。