[!info] related notes 算法面试题型 MOC LeetCode

面试算法学习方案

可以把“面试算法题”当成一门应试型技能来学，而不是当成“刷得越多越强”的玄学。真正有效的学习路径，一般是：

一、先明确目标：你学的不是算法竞赛

面试算法题的目标通常不是：

• 追求特别偏、特别难的技巧
• 手写非常复杂的数学证明
• 靠记住 1000 道题的答案

而是这几件事：

1. 看到题能快速识别题型
2. 能在有限时间内给出正确、清晰、可解释的解法
3. 能把思路讲出来
4. 代码写得稳，边界处理不炸
5. 能从 brute force 一步步优化到更优解

所以学习重点应该是：

• 题型识别
• 模板化思维
• 复杂度分析
• 代码表达
• 口头沟通

不是盲目题海战术。

---

二、最常见的误区

1. 一上来就狂刷题

很多人一开始就每天 10 道题，但做完很快忘。原因是没有建立知识框架，题目只是“见过”，没有“掌握”。

2. 只看懂题解，自己不会写

“看懂”不等于“会做”。算法学习里最容易自我感动的就是：

• 题解一看就懂
• 关掉题解就不会

3. 只记题，不记方法

真正该记的是：

• 什么特征对应什么方法
• 这个方法的状态/不变量是什么
• 什么时候会超时
• 常见坑在哪里

4. 只练最优解，不练表达

面试不是 OJ。你不能只会最后那版代码，还得会说：

• 我先从朴素思路开始
• 为什么它慢
• 我怎么优化
• 为什么这个优化成立

5. 贪难题，忽视基础题

大多数面试的区分点，不是你会不会某道神题，而是你能不能把：

• 二分
• 双指针
• DFS/BFS
• 哈希
• 堆
• 动态规划基础题
  写得又快又稳。

---

三、正确的学习框架：按“题型”学，不按“题号”学

最有效的方法，是把面试题拆成几个核心模块，逐个攻破。

第一层：数据结构基本功

这些不是为了背定义，而是为了在题里熟练调用。

• 数组 / 字符串
• 链表
• 栈 / 队列 / 单调栈 / 单调队列
• 哈希表 / 哈希集合
• 堆 / 优先队列
• 树 / 二叉树 / 二叉搜索树
• 图
• 前缀和 / 差分
• 并查集
• Trie
• 位运算基础

目标是：

• 知道每种结构适合解决什么问题
• 知道常见操作复杂度
• 能手写基础遍历和操作

四、方法卡 / 错题本模板（建议直接照抄）

每道高频题建议沉淀成一张“方法卡”，不要把错题本写成题目仓库。

题目：
题型：

识别信号：
- 

朴素解法：
- 
复杂度：

优化观察：
- 

最终解法：
- 
复杂度：

易错点：
- 

复习计划：1d / 3d / 7d / 14d（四刷法）

---

第二层：核心算法思想

这是面试高频。

1. 模拟

很多题其实不难，主要考代码能力和细节处理。

你要学会：

• 先定义规则
• 再确定状态如何更新
• 最后处理边界

2. 双指针

常见特征：

• 数组/字符串
• 连续区间
• 有序数组
• 子串/子数组

典型问题：

• 去重
• 合并
• 滑动窗口
• 两数之和变体
• 最长/最短满足条件区间

3. 二分查找

不要把二分只理解成“在有序数组中找值”。

更重要的是二分答案：

• 最小化最大值
• 最大化最小值
• 满足某条件的临界点

你要练的是：

• 左闭右闭 / 左闭右开写法固定化
• mid 写法
• 循环不变量
• check 函数设计

4. DFS / BFS / 回溯

典型场景：

• 树遍历
• 图遍历
• 连通块
• 排列组合子集
• 状态搜索

要掌握：

• 什么时候 DFS
• 什么时候 BFS
• 回溯的“路径、选择列表、结束条件”
• 剪枝怎么做

5. 贪心

难点不在写代码，而在证明“为什么局部最优能导出全局最优”。

面试里常见贪心题一般有明显模式：

• 排序后处理
• 优先选择当前最优
• 区间问题
• 资源分配问题

6. 动态规划

很多人最怕这个，但其实可以按层学。

先学最基础的：

• 线性 DP
• 背包
• 子序列 DP
• 区间 DP（了解）
• 树形 DP（进阶）

做 DP 一定强制自己回答四个问题：

1. dp[i] 或 dp[i][j] 表示什么？
2. 状态转移从哪里来？
3. 初始值是什么？
4. 遍历顺序为什么这样？

不会这四个问题，就说明还没真正理解。

7. 图论基础

面试里一般不会考太深，但这些很常见：

• BFS 最短路（无权图）
• 拓扑排序
• 并查集判连通
• 岛屿类问题建模

8. 前缀和 / 差分 / 单调结构

这类很高频，但很多人系统学得少。

• 前缀和：快速求区间和
• 哈希 + 前缀和：子数组和类问题
• 单调栈：下一个更大元素、柱状图
• 单调队列：滑动窗口最值

---

五、推荐学习顺序

这是比较适合大多数人的顺序：

阶段 1：基础入门

先把这些打牢：

• 数组 / 字符串
• 哈希表
• 双指针
• 栈 / 队列
• 链表
• 二叉树基础遍历
• 二分查找
• BFS / DFS 基础

这个阶段的目标是：

• 80% 简单题和基础中等题能独立做
• 能写出不太出 bug 的代码

---

阶段 2：高频中等题

然后系统学：

• 滑动窗口
• 回溯
• 堆
• 前缀和
• 贪心
• 动态规划基础
• 图基础
• 单调栈

这个阶段很关键。大多数公司的算法面试，核心区分度都在这里。

---

阶段 3：专项突破

如果你已经有一定基础，再补：

• 并查集
• Trie
• 区间 DP
• 树形 DP
• 二分答案
• 拓扑排序
• 最短路基础
• 位运算技巧

---

五、每道题应该怎么学，才不会白刷

我建议你对每道题走这个流程：

第一步：先独立想 20~30 分钟

不要一眼看题解。你可以分层次尝试：

• 能不能先写暴力？
• 暴力瓶颈在哪？
• 有没有重复计算？
• 能不能用更合适的数据结构？
• 能不能排序后处理？
• 能不能用哈希换时间？
• 是不是某种已知题型？

如果 20~30 分钟完全没思路，再看提示或题解。

---

第二步：题解不是“看完”，而是“拆开”

看题解时不要只看最终代码，要强迫自己搞懂：

• 这题属于什么题型？
• 关键观察是什么？
• 为什么想到这个方法？
• 时间复杂度为什么能降下来？
• 最容易写错的是哪里？

---

第三步：关掉题解，自己重写

这是最关键的一步。

要求至少做到：

• 不看代码，自己写一遍
• 能通过样例
• 能解释主要逻辑

如果做不到，就说明这题还没真正掌握。

---

第四步：复盘成“方法卡”

不要把题收藏完就结束。你需要给自己沉淀一张方法卡，比如：

题目标签

• 哈希 + 前缀和

识别信号

• 求“连续子数组”
• 问是否存在/个数/最长长度
• 和、余数、前缀差值有关

核心技巧

• 枚举右端点
• 用哈希记录某个前缀状态最早/出现次数

易错点

• 前缀和初值
• 下标偏移
• 重复更新时取最早还是最新

这样你记住的是“方法”，不是“答案”。

---

六、如何建立“题感”

所谓题感，本质上不是天赋，而是模式识别能力。

你看到一道题，脑子里应该自动出现一些判断：

1. 数据范围在暗示什么？

例如：

• n 很小：可能是暴力、回溯、状态压缩
• n 到 1e5：通常要 O(n) 或 O(n log n)
• 图边很多：注意邻接表、BFS/DFS、并查集
• 要求多次区间查询：前缀和 / 线段树（如果真高阶）

2. 题目在问什么？

• “是否存在” → 哈希 / 搜索 / 判定
• “最大/最小” → 二分答案 / DP / 贪心 / 单调结构
• “所有方案” → 回溯
• “最短路径/最少步数” → BFS
• “连续区间” → 双指针 / 前缀和
• “子序列” → DP 很常见

3. 输入本身有什么特征？

• 有序 → 二分 / 双指针
• 树 → DFS / BFS / 递归
• 字符串 → 双指针 / 哈希 / DP / Trie
• 区间集合 → 排序 / 贪心 / 扫描线思维

---

七、动态规划到底怎么学

很多人卡在 DP，我单独讲一下。

1. 不要一上来碰特别抽象的 DP

先按难度梯度来：

• 爬楼梯
• 打家劫舍
• 最大子数组和
• 不同路径
• 最长递增子序列
• 最长公共子序列
• 编辑距离
• 0/1 背包

先把“状态定义”和“转移”这个核心吃透。

2. 先从递归理解，再写迭代

很多 DP 题本质是：

• 大问题拆成小问题
• 子问题会重复

你先写记忆化搜索，搞清楚“函数定义”和“递归关系”，再改成 DP 表，理解会更自然。

3. 每次都写出状态含义

比如：

• dp[i]：以 i 结尾的最优值
• dp[i][j]：考虑前 i 个物品，容量为 j 时的最优值

只要状态定义模糊，后面一定乱。

4. DP 的本质是“枚举决策”

比如打家劫舍：

• 抢第 i 家
• 不抢第 i 家

背包：

• 选当前物品
• 不选当前物品

子序列：

• 匹配
• 不匹配

学会抓“决策分叉点”，DP 就清晰很多。

---

八、面试里怎么把题“讲出来”

这个特别重要。

很多人会做，但讲不好，面试体验就会差很多。

建议你固定成这种表达结构：

1. 先确认题意

用自己的话复述：

• 输入是什么
• 输出是什么
• 有哪些边界情况

2. 先给朴素思路

比如：

• 最直接的方法是枚举所有区间
• 复杂度是 O(n^2) / O(n^3)，会超时

这会显得你思路完整，而不是凭空跳最优解。

3. 再说优化观察

比如：

• 我注意到我们反复计算区间和，所以可以用前缀和
• 因为数组有序，所以可以双指针
• 因为要快速判断是否见过某状态，所以可以用哈希表

4. 明确算法和复杂度

• 时间复杂度
• 空间复杂度
• 为什么成立

5. 写代码时边写边说明关键点

不是逐行念代码，而是强调：

• 这个变量代表什么
• 为什么这里更新
• 为什么这里先判断再移动

---

九、代码能力怎么练

面试算法题不是只拼思路，也拼代码稳定性。

要重点训练这些能力：

1. 模板熟练度

这些最好能比较顺手地写出来：

• 二分模板
• BFS/DFS 模板
• 回溯模板
• 前序/中序/后序遍历
• 堆的基本用法
• 滑动窗口模板
• 并查集模板

2. 边界意识

经常出错的点：

• 空数组 / 空字符串
• 只有一个元素
• 全相等 / 全不相等
• 下标越界
• 死循环
• 整数溢出
• 递归终止条件漏写

3. 调试能力

写完别急着交，至少自己过一遍：

• 用最小样例手推
• 指针移动是否正确
• 哈希表更新时机是否对
• 初值是否合理
• 返回值是否覆盖全部情况

---

十、如何安排每天学习

给你一个比较实用的日常训练方式。

如果你是初学者

每天 2~3 小时足够，重点是稳定。

方案：

• 30 分钟：复习昨天题目
• 60 分钟：学一个专题
• 60 分钟：做 2~3 道相关题
• 20 分钟：复盘记录

不要一上来追求数量。

---

如果你已经有基础，要准备面试

可以这样安排：

平时

• 1 个专题复习
• 3~5 道高频题
• 1 道限时模拟题

每周

• 做一次 45~60 分钟模拟面试
• 回顾错题和没写顺的模板
• 复盘本周最常卡的题型

---

十一、错题本应该怎么做

错题本别记成“题目仓库”，要记成“失误仓库”。

建议每题只记录这几项：

项目	记录内容
题型	双指针 / DP / 图 / 哈希
错因	没想到思路 / 复杂度判断错 / 代码 bug / 边界漏了
关键信号	哪些题面特征提示这个方法
核心转化	暴力怎么优化到正解
易错点	下标、初始化、更新顺序等
复习时间	1 天后、3 天后、7 天后、14 天后

这样错题本才真的有用。

---

十二、刷题数量大概多少才够

没有一个绝对数字，但大致可以这样看：

1. 入门期

重点不是数量，而是把高频题型都见过一轮。

2. 求稳期

通常你需要做到：

• 常见题型基本能识别
• 中等题不会一脸空白
• 基础模板能快速写

很多人到这个阶段，可能在 150~250 道左右会比较有感觉。

3. 冲刺期

不是继续无脑加数量，而是：

• 提高 medium 的命中率
• 降低 bug 率
• 提高表达流畅度
• 限时训练

所以“刷多少道”不是核心，同一类题是否真正吃透才是核心。

---

十三、不同水平的人分别该怎么学

1. 完全零基础

重点：

• 先学数据结构和常用模板
• 先做 easy 和基础 medium
• 不要一上来碰硬核 DP、图论进阶

2. 会一点，但做题很慢

重点：

• 专题化训练
• 题型识别
• 限时练习
• 复盘提炼方法卡

3. 思路有，但代码容易错

重点：

• 多手写
• 多做模板默写
• 做完强制手测边界
• 练口述 + 手写同步

4. 平时能做，面试容易慌

重点：

• 模拟面试
• 训练“先讲后写”
• 练在压力下保持结构化表达
• 固定答题节奏

---

十四、一个非常实用的训练方法：四刷法

对高频经典题，我很推荐“四刷法”。

第一刷：自己做

能做多少做多少。

第二刷：看题解并理解本质

搞懂为什么这么做。

第三刷：隔天重做

不看题解自己写。

第四刷：一周后口述

不一定写代码，但要能完整讲出：

• 题型
• 思路
• 优化点
• 易错点

这样才能从“见过”变成“会”。

---

十五、面试前冲刺怎么复习

如果快面试了，不要再无限开新题。

应该做的是：

1. 回看高频题型

• 哈希
• 双指针
• 二分
• BFS/DFS
• 回溯
• 堆
• DP 基础
• 贪心
• 单调栈
• 树

2. 重刷错题

优先刷：

• 以前不会的
• 会思路但写挂的
• 容易忘模板的

3. 做限时训练

比如：

• 30 分钟 1 题
• 45 分钟 2 题

4. 练表达

你至少要能自然说出：

• 朴素解法
• 优化过程
• 复杂度
• 边界情况

---

十六、给你一个很务实的总原则

学习算法题最有效的一句话是：

少刷一点，想深一点；少记答案，多记模式。

你真正要建立的是这三个能力：

• 识别能力：这题像什么
• 转化能力：暴力怎么变成高效
• 表达能力：怎么把思路讲清楚

只要这三点起来了，算法面试水平会明显提升。

---

十七、一个可直接执行的 8 周学习方案

第 1~2 周

• 数组、字符串、哈希、双指针
• 每天 2~3 题
• 建立错题本和方法卡

第 3 周

• 栈、队列、链表、二分
• 模板反复写熟

第 4 周

• 树的 DFS/BFS、递归
• 经典遍历和层序题

第 5 周

• 回溯、排列组合子集
• 练剪枝和状态恢复

第 6 周

• 堆、前缀和、滑动窗口、单调栈

第 7 周

• 贪心、DP 基础

第 8 周

• 图基础、并查集、综合复习
• 开始限时模拟

---

最后给你一个判断标准

你不是在“学会一道题”，而是在判断自己是否达到了这 5 条：

• 能识别题型
• 能独立推出思路
• 能写出正确代码
• 能分析复杂度
• 能清楚讲给别人听

只要这五条能做到，面试算法题基本就进入正循环了。

我还可以继续帮你整理一版更具体的内容，比如：

两个可选方向

1. 给你一份“算法面试学习路线图（按题型+推荐题单）”
2. 给你一份“适合 2 个月准备面试的每日刷题计划表”