指南：大厂资深 coding 面试

这篇写给谁

一位后端或全栈工程师，正准备在接下来 1–8 周内面试 FAANG 级别公司的中到资深 岗位——Meta E4/E5、Google L4/L5、Amazon SDE II/III，或 Apple、Netflix 以及 大厂邻近梯队里的同等级别。你一直在刷 LeetCode。你没把握的，是到底该怎么把整 场面试跑下来——如何从读一道题走到一份干净、经得起追问、测试过的解法，全程口 述，还在计时下完成。

这就是那本操作手册。它不是又一篇讲怎么解 LeetCode 题的文章——它讲的是如何 在面试当场表现。

它在哪个位置：coding 准备体系

三篇文章做三件不同的事。按这个顺序读：

它们互补，不重叠。本指南假设你已经能识别模式（那是框架的职责），也有题可练 （清单的职责）。这里，瓶颈是计时压力下的执行。

如果你的目标是 E4/L4，这套工作流照用即可；全文标出的那些资深专属动作，对你这 个级别是伸展目标。

自我评估：你卡在哪？

核心洞察

一道熟悉的 medium，干净地、口述地、在 20 分钟内解出来。 把这个练成，每一 种 loop 变体都退化成一道包装题；跳过它，再多公司专属的小技巧也救不了这一轮。

这个级别的 coding 轮，评分的形状和大多数候选人以为的不一样。天真的模型是”解出 题目，最好是最优解”——没错，你要是解不出来就拿不下这一轮。但中级和资深之间的 差值，不在题目难度，而在计时压力下的执行质量：干净的代码、清晰的沟通、关 于时间往哪花的校准决策。资深候选人不只是解题——他们在时间压力下做工程决 策，并让那些思考被听见。

这就是为什么本指南是一套工作流，而不是一份技巧清单。只有一套流程；每一道题都 跑同一套；资深是执行这套流程的一种方式，而不是一个独立的话题。

这一轮到底在打分什么

大多数给出了正确解法却仍拿到 no-hire 的候选人，都对结果感到困惑。问题几乎总是 某一个维度停在 0–1，而正确性其实没问题：

下面这套工作流，就是为了把这几行里的每一行从中级列推到资深列而设计的。这是面试 官在一轮出色表现后可能写下的：“很快识别出 sliding-window 模式（1.5 分钟）。选定 前先点了 hash-map 备选。代码干净——命名好，还抽了个窗口校验的 helper。漏了空字符 串的边界情况，但自测时抓到了。干净地处理了’放不进内存’的追问——分块处理的 external sort。Strong hire。” 每一句都对应一个工作流步骤。

各公司的轮次形态

通用的一轮是 45 分钟：开场（5）、coding（约 35）、提问（5）。coding 窗口里发生 什么则因公司而异——而这些差异改变了哪些工作流步骤分量最重：

有两点值得内化：

• 前几步的速度是普适的开局。 在 Meta 它就是整个游戏；在 Google 它为追问买 时间；在 Amazon 它为 LP 问题留出余地。一次快速的首解能打开每一扇门。
• 和 recruiter 确认你这条 loop 的形态。 “每轮几道题、有没有追问、什么环境 （CoderPad、Google Docs）？“是个正常的问题，而答案会改变你的节奏。

面试工作流

每一道题都跑同样的七个步骤，按顺序。这是整轮的脊柱：读到一道题，你从不需要即兴 决定下一步做什么——你在执行一套已知的流程，这让你的注意力得以腾出来给真正的 工作。

而从步骤 3 开始，真正的工作就是工程决策。这是贯穿始终的主线：一场面试是一 连串选择——哪种思路、哪种数据结构、接受哪个权衡、约束变了怎么适配——每一个都带 着理由被大声说出来。沟通不是叠在上面的一项独立技能；它是决策变得可见的方式。 “资深”不是一个独立的章节；它是把那些决策做得更审慎。下面每一步都带一个资深做 法——一句多出来的推理，把这一步抬高一个层次。

flowchart TD
  S1[1 · 理解] --> S2[2 · 识别] --> S3[3 · 评估选项] --> S4[4 · 确定] --> S5[5 · 实现] --> S6[6 · 验证] --> S7[7 · 应对]
  S1 -.资深信号.-> G1[问题选择]
  S2 -.-> G2[模式识别]
  S3 -.-> G3[权衡推理]
  S4 -.-> G4[校准判断]
  S5 -.-> G5[生产级代码]
  S6 -.-> G6[失败模式测试]
  S7 -.-> G7[约束推理]

  classDef step fill:#fdf1e3,stroke:#b45309,stroke-width:2px,color:#1f2937;
  classDef sig fill:#f3ecfb,stroke:#8250df,stroke-width:1px,color:#1f2937;
  class S1,S2,S3,S4,S5,S6,S7 step
  class G1,G2,G3,G4,G5,G6,G7 sig

步骤 1–4 合计不到 5 分钟。大头留给实现，那才是它该在的地方。有两条规则贯穿所有 步骤：不要跳步（跳过澄清省下 90 秒，等你写到一半发现读错了输入，代价是 6 分 钟），以及不要撑大步骤（4 分钟的澄清是拖延，不是准备）。

步骤 1 —— 理解题目

用你自己的话复述题目，然后问那 1–2 个会改变你思路的问题：输入有序吗？值能为 负吗？预期规模多大？平局怎么打破？这是你首次沟通的地方——在任何代码之前，你和面 试官对”你在解什么”达成一致。

步骤 2 —— 识别模式

在选算法之前，先识别这是哪一类问题——识别类别会为随后每一个决策定调。

本指南不教识别——识别框架 才教。 跑它的识别顺序，落到一个类别上，你就得到这一步的产出：“这是一道 Traversal 问题”，或”这是带 sliding window 的 State Maintenance”。如果在一道熟 悉的 medium 上你没法在大约一分钟内做到这点，那是框架和刷题的缺口，不是轮次机制的 缺口——先去那边补上。

步骤 3 —— 评估选项

识别收窄了范围；现在真正的工作开始了——这一轮变成一连串工程决策，而这是第一个。 一旦你知道了类别，通常执行它的方式不止一种。在确定之前说出可行的思路及其权 衡——这是算法推理的得分点，而如果你直接开始写代码，它就不可见。

“两个选项：用 heap 做 O(n log k)，适合流式；或者先排序 O(n log n)，但更简单、 无需额外结构。”

步骤 4 —— 确定

确定一种思路，把这个选择系到这道题的约束上，并在动手打字前报出复杂度：

“hash map 在这里胜出，因为流式追问需要单次遍历——O(n) 时间，O(n) 空间。”

这里也是放弃最优解这个判断的所在。如果你已经有一个能跑的 O(n log n)，看到一 个 O(n) 但只剩 10 分钟，别默默交上更慢的那个，也别盲目重写——把它说出来：“我有 一个能跑的 O(n log n)。我看到用 hash map 的 O(n)——要我重写，还是继续往下走？” 面试官几乎总会说”往下走，把重构思路讲给我听”，然后你干净地回答。和默默交一份次优 解同样的终局，分数好得多。

步骤 5 —— 实现

现在把它写出来。这里有三件事承载分数——如何写出干净面试代码的具体机制在下面的 实现原则里；当下，专注于：

1. 讲解决策，而非动作。 别说”我现在在写一个 for 循环”——面试官看得见这个循环。 要说*“我用循环而不是递归，因为输入可能很大，递归有 stack overflow 的风险。“*决 策才是信号。
2. 一次就写干净。 好的命名、小函数、无重复——在计时下就做到，而不是当作事后的 清理。写得可读比重构更省。
3. 走到哪就处理哪的边界情况， 大声说出来——为空输入加一个提前返回，在你写它的 时候就点名，而不是最后再补上去。

步骤 6 —— 验证

走一遍你实际写的代码——逐行——先用一个具体输入，再用一个刻意的边界情况（空输 入、单个元素、重复、边界值）。用真实例子、大声地测试，既是验证也是沟通：面试官看 着你抓到自己的 bug。

步骤 7 —— 应对追问

追问不是附录——在 Google、Meta E5 和 Amazon L6，它们就是这一轮的输赢所在。面试官 会变异这道题：“如果放不进内存怎么办？""如果更新是并发到达的怎么办？""如果允许重复 怎么办？“他们往往在评估你能否扩展一个已有解法、在新约束下推理——而不是你有没有产 出第一个解法。 一个搞定了初始解却在变异上僵住的候选人，得分低于一个解得凑合但适 配流畅的候选人。

大多数候选人在这里僵住，因为他们准备了解法，没准备适配。每一次都跑这套 5 步流程：

1. 复述新约束。 “所以现在输入放不进内存了——我们需要一个流式或外部的方法。”
2. 解释为什么旧解法崩了。 “我的 hash map 需要 O(n) 内存，超过 RAM 就行不通。”
3. 提出新思路。 “我会换成带分块处理的 external sort——把放得下的块排序，再 merge。”
4. 分析新复杂度。 “O(n log n) 时间，O(chunk-size) 空间；merge 是一个 k-way heap merge。”
5. 说出它的代价。 “我们失去了随机访问——查询需要重新扫描或加一个 index。”

常见的追问家族及其考察的东西：

当局面走偏：恢复流程

每个候选人真正担心的那个问题——万一我卡住了怎么办？ 最常见的失败是一道题吃掉了 12 分钟预算里的 18 分钟：你读错了输入，或追了一个错误的思路。慌张是自然的，也是 错的。

1. 在心里重置时钟。 剩下多少，只要不浪费，都够解一道 medium。
2. 压缩步骤 1–2。 30 秒理解，说出模式，往下走。
3. 从暴力解法开始。 说出来——“我先从这里开始，有时间再优化”——然后写。一个 能跑的暴力解法，永远胜过一个进行到一半的最优解。
4. 口头拿下优化。 “这是 O(n²)；O(n log n) 用一个 heap，我接下来会写它。”

如果什么都想不出来，就把暴力解法大声说出来并写它——一旦嵌套循环让冗余的工作变得 可见，模式通常就自己浮现了。一个能跑、并引向口头优化的暴力解法，永远胜过僵住的沉 默。

实例演练：Merge Intervals

在 56. Merge Intervals 上跑这七 步，每步一行——一次约 12 分钟的解：

1. 理解： merge 重叠的 [start, end] 区间——有序吗？start 能等于 end 吗？（未 排序；能。）
2. 识别： 一道 Ordering 问题——正确性依赖于有序。
3. 评估： sort + 线性扫描，或一棵 interval tree（对一次性 merge 是杀鸡用牛刀）。
4. 确定： 按 start 排序，扫描，重叠时扩展当前区间——O(n log n) 时间，O(n) 输出。
5. 实现： 在你跟踪当前已合并区间时，讲解这次扫描。
6. 验证： 跑 [[1,3],[2,6],[8,10]]，再跑相接的边界情况 [[1,4],[4,5]] → [1,5]。
7. 应对： 如果区间是流式进来、放不进内存 → 按 start 做 external-sort，同样的扫描。

诊断与训练

失败诊断

一致的 mock 反馈会映射到一个具体的工作流步骤：

就绪清单

具体的关卡——不是”我感觉准备好了吗？“而是”我能不能可证明地做到？”

• 在 ≤20 分钟内用干净代码 + 完整讲解解出一道熟悉的 medium
• 在 ≤25 分钟内解出一道陌生的 medium（3 分钟思路，15 分钟代码，5 分钟测试）
• 在 <1 分钟内说出一道随机 medium 的识别类别
• 凭记忆在各 <5 分钟内写出 sliding-window / BFS / heap-top-k 模板
• 从一张白纸在 ≤25 分钟内实现 LRU Cache
• 用那套 5 步阶梯，在 <5 分钟内端到端处理一个追问变异
• 在 ≤2 分钟内陈述任意 medium 的思路，并让一个 mock 搭档认同它清晰
• 一口气解释一个正确的 O(n log n) 并说出 O(n) 备选

勾选 7 项以上：接近就绪。少于 5 项：先补缺口，再约面试。

5 分钟复盘

每次 mock 之后、看题解之前：

1. 哪个工作流步骤花的时间最长？ 那是你的瓶颈——去练它。
2. 哪一行信号得分最低？（正确性、速度、沟通、代码质量、应对力、测试。）那是你 下一个聚焦点。
3. 你会换成怎么说？ 写下那句能让它”明显资深”的话，下一遍就大声说出来。

AI 时代的 coding 面试

截至 2026 年年中，AI 正越来越多地削弱纯实现速度的价值——那些它做得好的步骤 5 机 制（语法、样板、标准模式）。工作流不变；分量转移到推理步骤上——理解（1）、决策 （3–4）和适配（7）——这些是 AI 在一场实时对话里没法替你做的。如果你的 loop 包含一 个显式的 AI 辅助轮，读指南：AI 原生 coding 面试。

实现原则

步骤 5 的参考——如何让你在 30 分钟里写的代码，读起来像你凭本能就在写生产代码。在 准备阶段把这些练到自动化，这样在轮次里它们是本能，而不是你盯着时钟时还要想的东西。

• 好的命名。 left、right、count 胜过 l、r、c——命名是面试官不用问就 能读懂你代码的方式。
• 小的 helper 函数。 把重复逻辑抽成一个命名过的 3 行 helper；它显示分解的本能。
• 单一职责，无重复逻辑。 两个一模一样的块是一次错过的抽取，而面试官会注意到。
• 防御性的边界情况， 在你写它们时就点名——为空输入加提前返回、边界检查。

关于语言：对大多数候选人，Python 是对的选择——每个算法更少的击键，而 Counter / heapq / deque / defaultdict 直接落在常见模式上。例外是系统/基础 设施岗位，那里团队的 C++/Go 信号更契合。无论你选什么，都把它当生产代码来写——在 Amazon 那是明写的评分标准，在别处它是一个无声的加分项。

接下来做什么

准备就是：刷识别（框架）→ 练题目（清单）→ 在这套工作流上跑完整的计时轮次。

• 4 周以上： 按识别顺序、拿着秒表跑题目清单；从第 3 周起，每周两场按你目标公司形态的完整计时 mock，跑全部七步。
• 2 周： 放弃 hard；在 easy/medium 上练步骤 1–6 的速度；每题两个追问变异（步骤 7）；每周两场 mock。
• 1 周： 不学新模式——在你会的题上热身识别；每周两场独自的、全速的 mock，跑完 整个工作流。
• 24 小时： 一道 easy、一道 medium，带讲解跑完整工作流，然后停下。

相关

• 问题识别框架 — 工作流的步骤 2：如何识别你面对的是哪一类问题。
• 清单：面向 FAANG loop 的 LeetCode — 练什么：约 60 道题按识别类别组织，附各公司注释。
• 指南：Amazon 的 Logical & Maintainable coding 面试 — 步骤 5（干净代码）成为明确评分标准的地方。
• 计划：资深后端软件工程师面试准备 — 如何把以上这一切在 12 周里排序。