LeetCode热题100刷题指南：高频考点与三轮高效刷题计划

聊 LeetCode 热题 100 之前，先说个我自己的经历。去年带一个学弟准备暑期实习，他算法底子一般，每天刷题刷得挺猛，但刷到第三周反而焦虑了——题量上去了一百多道，可一合上题解，脑子里还是空的。我给他的建议很简单：立刻停掉那些零散的刷题计划，把 LeetCode 热题 100 这一份题单吃透，比什么都管用。

很多准备面试的朋友对这份题单有误解，以为它就是个普通题目合集，或者觉得题目太“经典”、怕面试官不按套路出题。实际情况恰恰相反。热题 100 是 LeetCode 官方从大量面试出题反馈里聚合出来的高频题，它反映的是各大公司在真实面试中反复出现的算法题分布。换句话说，你在这份题单里练过的每一类题目，都有很大概率在面试桌上原封不动地遇到。这篇文章我不会空谈“要不要刷题”，而是从这份题单的构成、考点分布、几个热门题型的解题模板、完整的刷题计划到避坑经验，一步步拆给你看。无论你是刚接触算法题的新手，还是已经刷了一部分题想体系化梳理的老手，这篇都能给你一个可以直接照着执行的方向。

1. 热题 100 是什么？先聊聊这份题单的含金量

1.1 它不是编辑随手整理的榜单

很多人以为热题 100 是 LeetCode 编辑根据“这题难不难”或者“这题有没有名”挑出来的。实际完全不是。这份题单的底层逻辑是数据驱动，它会聚合大量用户在面试中遇到的真实题目反馈，再结合题目被考察的频率、公司的分布等维度去筛选，最终保留下来的是面试中出现频率最高的 100 道题。

这意味着什么？意味着它更新的不只是题目本身，更是当前面试趋势的“晴雨表”。比如这几年动态规划相关题目在公司面试里出现频率变高，热题 100 里 DP 类题目的比重和排序就会跟着调整。所以网上有人每隔几个月回顾热题 100，都会发现榜单有细微变化，这是正常的，恰恰说明它是活的、贴近实战的。

这个特点也决定了它的适用范围非常广。准备校招的应届生刷它，是为了覆盖面试高频考点；准备跳槽的职场人刷它，是为了快速恢复算法手感；就算你不面试，拿它当算法基本功的训练清单，也比自己漫无目的找题做高效得多。

1.2 和 Blind 75、面试经典 150 比，怎么选

刷题圈子里还流传着另外两份有名的题单，一份是 Blind 75，一份是面试经典 150。经常有人问我“到底刷哪个”，我的回答是：看你的时间和你处在什么阶段。

我的建议很简单：如果时间只有 4 到 8 周，优先热题 100，因为它的选题逻辑最贴近“面试官真实会问什么”；如果刷完热题 100 还有余力，再去经典 150 里补充同类型变种，这时候不是从头刷，而是挑自己不熟的考点补短板。Blind 75 我更推荐作为查漏补缺的“快速清单”，而不是主刷题单——它有些题目和热题 100 重叠，有些却偏老，对国内面试场景的覆盖不如热题 100 精准。

1.3 难度构成：别被中等题的数量吓到

热题 100 的难度分布大致是三成简单题、六成中等题、一成多困难题。这个比例其实相当科学。简单题用来建立信心和巩固基础语法，中等题是面试真正的“主战场”，困难题则负责拉开区分度，也是筛选高分候选人（比如一些大厂的终面）的主要手段。

对新手来说，我的建议是前期不要碰困难题。先把简单题和中等题刷扎实，困难题留到第二轮甚至第三轮再攻坚。对已经有基础的朋友来说，也不要轻视简单题——热题 100 里的简单题往往考察的是常用数据结构的熟练度，比如链表的反转、快慢指针、哈希表的去重，这类题在面试开场热身环节出现率极高，写顺手了能省下大量时间留给后面的难题。

2. 考点分布拆解：这 100 题到底在考什么

2.1 数据结构三大块：数组链表、哈希表、树

如果你把热题 100 的目录按考点归类，会发现一个很明显的规律：数组、链表、哈希表、二叉树这四类题加在一起，占了半壁江山以上。这不是巧合，而是因为绝大多数公司的面试官，倾向于用这几种“万精油”数据结构去考察候选人写代码的基本功。

数组相关的题目，核心不外乎双指针、滑动窗口、前缀和、模拟遍历这些套路；链表题则集中在反转链表、快慢指针找环、合并有序链表、删除倒数第 N 个节点；哈希表就更是百搭了，很多用暴力解法会超时的题，加上一个哈希表就能把时间复杂度从 O(n²) 降到 O(n)。树这一块则集中在二叉树的遍历、层序遍历、最近公共祖先、路径和等问题上，考验的是递归思维的熟练度。

我自己刷完一整轮之后的感受是：这些数据结构类题目，就像篮球里的运球和投篮，是所有人的基本功。面试时题目包装得再花哨，最后落脚点大概率还是这几类。所以刷热题 100 的时候，没必要被题目表面的“新题感”带偏，多问自己一句“这题底层是哪个数据结构的哪个经典操作”，刷完一轮你会发现自己有了“举一反三”的能力。

2.2 算法思想四大件：双指针、二分、动态规划、回溯

数据结构之外，热题 100 里最密集的算法思想就是这四类了。双指针和二分属于相对容易掌握的“套路题”，动态规划和回溯则是大多数人的分水岭。

双指针的题有个很明显的特征：题目里出现“有序数组”“子数组”“连续区间”这些字眼时，基本可以往双指针的方向想。滑动窗口本质上也是双指针的一种，处理“最长不重复子串”“最小覆盖子串”这类问题时屡试不爽。二分查找则更隐蔽一些，热题 100 里有一类“在有序数组里找目标”的题，还有一类是我们要在后面重点讲的“二分答案”类题目，后者是很多中等题的隐藏考点。

动态规划在热题 100 里的占比相当可观，背包问题、爬楼梯、零钱兑换、最长递增子序列这些高频题目全在里面。这一块没有捷径，唯一有效的方法是掌握“状态定义 + 状态转移方程”的思考框架，少背题解、多理解推导过程。回溯算法的核心就是“决策树”思维，全排列、组合总和、子集这些题练熟之后，你会觉得回溯反而是所有算法里最“模板化”的——一个递归函数加一个撤销操作的循环，几乎可以通吃。

2.3 容易被忽视但别跳过的考点：图、栈、堆、位运算

热题 100 里有几个考点占比不大，但出现频率不低，很多人在第一轮刷题时容易把它们跳过，等面试才发现躲不过去。我说的就是图论、栈、堆和位运算。

图论相关的题在热题 100 里不多，但都比较经典，比如岛屿数量（矩阵 DFS）、腐烂的橘子（多源 BFS）、课程表（拓扑排序）。这些题的核心是“不管图怎么给你，先用邻接表或方向数组把邻接关系抽象出来，再套 BFS/DFS 的模板”。栈相关的题主要考单调栈和表达式解析，前者解决接雨水、柱状图最大面积这类题，后者对应基本计算器等括号处理问题。堆则集中在 TopK 问题、合并 K 个有序链表、数据流中位数，考察的是对优先队列的理解。

位运算在热题 100 里属于“小而美”的存在，比如只出现一次的数字这类题，用异或操作可以写出非常优雅的解。这类题工作量不大，但性价比极高——因为很多候选人没准备到位运算，你掌握透彻的话，面试时反而能形成差异化优势。

3. 三道热搜题，三个万能模板

3.1 994 腐烂的橘子：多源 BFS 就得这么写

腐烂的橘子是热题 100 里 BFS 题型的代表，也是很多同学第一次接触“多源 BFS”这道坎。题目给你一个二维网格，1 代表新鲜橘子，2 代表腐烂橘子，0 代表空位，腐烂橘子每分钟会污染上下左右相邻的新鲜橘子，问最少几分钟后所有橘子都腐烂，如果做不到就返回 -1。

拿到这题的第一反应可能是对每个腐烂橘子分别做 BFS，然后再取最大值。这个思路能解，但会重复遍历很多格子，不是最优解。标准做法是把所有初始腐烂的橘子都当作“第一层”，同时放进一个队列里，然后一层一层往外扩展。这就是“多源 BFS”——把多个起点当成一个整体做层序遍历。

from collections import deque def orangesRotting(grid): m, n = len(grid), len(grid[0]) q = deque() fresh = 0 for i in range(m): for j in range(n): if grid[i][j] == 2: q.append((i, j)) elif grid[i][j] == 1: fresh += 1 if fresh == 0: return 0 minutes = 0 directions = [(1, 0), (-1, 0), (0, 1), (0, -1)] while q and fresh > 0: for _ in range(len(q)): x, y = q.popleft() for dx, dy in directions: nx, ny = x + dx, y + dy if 0 <= nx < m and 0 <= ny < n and grid[nx][ny] == 1: grid[nx][ny] = 2 fresh -= 1 q.append((nx, ny)) minutes += 1 return -1 if fresh > 0 else minutes

这段代码里有三个细节值得注意。第一，初始化时同时把腐烂橘子入队并统计新鲜橘子数量，这样可以在 BFS 过程中实时判断是否还有新鲜橘子，避免全部遍历完再检查。第二，外层循环用for _ in range(len(q))而不是while q，这是实现“按层扩展”的关键，每扩展一层minutes才加一，而不是每个节点加一。第三，遍历前先判断fresh == 0直接返回 0，这个边界条件不处理的话，遇到“一开始就没有新鲜橘子”的测试用例就会出错。

这道题的时间复杂度是 O(m×n)，因为每个格子最多被访问一次；空间复杂度最坏情况也是 O(m×n)，因为队列里可能同时存放大量腐烂橘子。面试时如果被问到“能不能优化”，你要知道在网格规模的约束下，O(m×n) 已经是最优复杂度了，往这个方向想基本就是在挖坑。

3.2 073 爱吃香蕉的狒狒：二分答案的套路

爱吃香蕉的狒狒（LeetCode 875）是热题 100 里“二分答案”类题目的经典模板。题目说的是有一排香蕉堆，每堆数量不同，狒狒每小时吃一堆里的 K 根香蕉，如果这一堆少于 K 根就全吃完并且这一小时不换堆，火车会在 H 小时后到，问最小的 K 能让她在 H 小时内吃完所有香蕉。

这类题有个统一的识别特征：题目让你求一个“满足条件的最小值（或最大值）”，而这个值的可行域是单调的——K 越大，吃完所有香蕉所需的小时数越少。遇到这种结构，直接暴力从 1 试到最大堆数量当然能过，但数据量一大就会超时；用二分查找去逼近答案，才是标准解法。

def minEatingSpeed(piles, h): left, right = 1, max(piles) def can_finish(k): hours = 0 for pile in piles: hours += (pile + k - 1) // k # 向上取整 return hours <= h while left < right: mid = (left + right) // 2 if can_finish(mid): right = mid else: left = mid + 1 return left

这个模板的精髓有两点。第一，can_finish(k)这个辅助函数的实现决定了二分能不能正确收敛。计算某堆香蕉需要几小时时，(pile + k - 1) // k是向上取整的标准写法，比math.ceil(pile / k)要快，而且避免了浮点精度问题。第二，注意二分的区间设计，左边界是 1（每小时至少吃 1 根），右边界是max(piles)（因为每小时吃超过最大堆数量的香蕉没有意义，时间也不会再减少）；当can_finish(mid)为真时，说明速度够快，可以让右边界往左收缩去找更小的可行值，但要注意right = mid而不是mid - 1，因为mid本身可能就是答案；反之，速度不够时left = mid + 1。

时间复杂度的计算也很有讲究：二分外层是 O(log(max(piles)))，内层检查函数对每个堆做一次计算是 O(n)，总复杂度是 O(n log(max(piles)))。面试官问到复杂度时，如果能答到这个层面并且把“为什么对数部分是跟着堆的最大值走”说清楚，说明你是真懂了二分答案，而不是背了个模板。

3.3 基本计算器：括号类表达式解析的关键

基本计算器（LeetCode 224）在热题 100 里属于“栈”这个分类，题目给你一个字符串表达式，包含加减运算和括号（以及空格），要求你算出结果。这题表面是数学问题，实际考的是你用栈处理嵌套结构的能力。

核心思路只有一个：把括号拆开，把减号当成“负号”来用。遇到左括号时，把当前结果和括号前的符号保存到栈里，进入括号后重新累积结果；遇到右括号时，把括号内的结果乘以括号前的符号，再和栈里存的外层结果相加。整个过程中不需要处理乘除，所以代码可以写得比较精简：

def calculate(s): stack = [] num = 0 sign = 1 result = 0 for ch in s: if ch.isdigit(): num = num * 10 + int(ch) elif ch == '+': result += sign * num num = 0 sign = 1 elif ch == '-': result += sign * num num = 0 sign = -1 elif ch == '(': stack.append(result) stack.append(sign) result = 0 sign = 1 elif ch == ')': result += sign * num num = 0 result *= stack.pop() # 乘上括号前的符号 result += stack.pop() # 加上括号外的累加结果 if num: result += sign * num return result

我看过很多人在这个题上踩坑，最常见的错误有两个。一个是漏掉对空格的处理，代码里遇到空格什么都不做就行，这个题不像某些表达式题要求你维护 token 流，空字符跳过即可；另一个是处理多位数时忘记num = num * 10 + int(ch)这个累加逻辑，导致遇到两位以上的数字就算错。此外，所有对result += sign * num的操作之后都要把num归零，否则下次读到数字时会叠加进旧值。

这题的难度在于你需要把“符号状态”和“数字状态”分开管理，想清楚每个字符出现时哪些变量需要更新、哪些需要重置。一旦想明白了，你会发现这类“带括号的表达式”题都是同一个套路，以后遇到带乘除、带幂运算的变种，核心仍然是“用一个栈保存括号边界处的上下文状态”。

4. 刷题计划怎么排：三轮刷题法

4.1 第一轮：按专题分类刷，不求快

很多人刷热题 100 的第一轮就犯一个错误：按照题号顺序从 1 刷到 100。题号顺序不等于知识体系顺序，如果你今天刷一道链表题、明天刷一道 DP 题、后天又跳回数组题，你的大脑很难在这么跳跃的输入中建立模式识别，刷完一轮下来感觉就是“每题都是新题”。

第一轮的正确打开方式是把热题 100 按考点分类，同一类型集中刷。比如连续三天只刷双指针和滑动窗口，你会在第三天突然发现“诶，这题和昨天那道题分析的思路一模一样”。这种“顿悟感”就是专题训练的价值——它迫使你在短时间内大量重复同一种思维模式，直到形成肌肉记忆。我自己的节奏是每天 2 到 3 题，一个专题大约花 4 到 5 天，整个一轮下来差不多 6 到 8 周。别嫌慢，第一轮慢是正常的，慢是在积累模式库。

这一轮里有个“时间盒”原则：一道中等题最多给自己 45 分钟到 1 小时，超过就直接看题解，但看完题解不能一走了之——合上题解，自己重新把代码写一遍，然后隔天再写一遍。你必须把“理解别人的解法”变成“自己能独立复现”，才算真正掌握这道题。

4.2 第二轮：乱序混刷，模拟真实面试

第一轮按专题刷完之后，你以为自己对热题 100 已经了然于胸，实际上这时候最危险——因为你知道当前在刷什么专题，看到题目自动就往这个专题的思路靠。真实面试根本不会告诉你这道题属于哪个专题，所以第二轮的核心动作是“去标签化”。

具体做法：把热题 100 里面的中等题和困难题打乱顺序，每天随机抽 3 到 4 道出来做，像模拟考试一样不看分类标签。做的时候给自己限时，一道中等题控制在 45 分钟以内，困难题放宽到 90 分钟；每个题做完之后要做的第一件事不是看题解，而是复盘“我一开始是怎么想方向的”“我卡在哪个环节”“如果重新再做一遍，第一步能不能更快地定位到正确思路”。这就是在练面试时最重要的能力——从陌生题目里快速识别模式。

第二轮还有一件重要的事：写复杂度分析。每道题做完，不管对错，都要写出时间复杂度和空间复杂度，并且试着和面试官一样追问自己“能不能优化”。这个习惯如果不刻意练，面试时很难答得严谨。

4.3 第三轮：错题重刷和模拟面试

第三轮的量级不用太大，重点放在“错题重刷”和“弱点补齐”上。我推荐一个很朴素但有效的办法：维护一个错题清单，记录你第一轮和第二轮中没做出来、超时、或者看了题解才写出来的题。第三轮就是把这份清单从头到尾再过一遍，原则上错题必须做到“不看题解、限时完成、一遍通过”。

这个阶段也可以开始用 LeetCode 的“模拟面试”功能，或者自己给自己安排 60 到 90 分钟的高压做题时间，题目从热题 100 中随机抽取。你可能觉得平时一对一刷题和限时模拟没什么区别，但真到了计时器滴答作响的时候，你的编码速度和心理状态会完全不同。提早适应这种压力，面试时才能稳住不慌。

5. 常见问题与避坑实录

5.1 “刷了忘、忘了刷”到底怎么破

这是我在各个刷题群里看到被问得最多的问题。今天会做的题，过两周再看，连题意都要读半天。这种情况太正常了，因为算法题的记忆不是线性记忆，它依赖的是“场景 + 模式”的联想。你第一次做对，可能只是记住了这道题的答案；过两周忘记，是因为你并没有为这道题建立足够的“提取线索”。

我的解法有两个。第一是空间间隔重复：每道题做完后，在第 1 天、第 3 天、第 7 天、第 30 天各回头重做一次。不是看一遍题解就完事，而是真正重新在代码编辑器里写一遍。第二是“用自己的话写题解”：给每道题写两三行注释，不用复杂，就写“这题的核心思路是什么、用了什么数据结构、边界条件是什么”。比如腐烂的橘子那题，你可以写“多源 BFS，注意层数计时和 fresh 提前返回”。这些注释是你自己的“提取线索”，比抄别人的题解有用十倍。

还有一个坑是过度依赖题解。很多人做题没思路就立刻翻题解，看完恍然大悟，然后觉得自己“会了”，这其实是虚假的掌握感。我的建议是至少给自己 30 分钟的独立挣扎时间，实在做不出来再看；看完之后必须经历“合上题解、重新自己写”这个过程。否则你会陷入“看题就会、做题就废”的循环，刷了一百题，最后面试一道变题就暴露了。

5.2 周赛要不要参加

热词里提到了周赛 430，正好聊聊这个话题。LeetCode 每周一场周赛，四道题难度递增。很多刷题者在准备期间会在“要不要参加周赛”之间摇摆。我的态度很明确：参加，但要摆正心态。

周赛最大的价值不是检测你的名次，而是模拟“限时 + 陌生题 + 压力环境”的真实战场。平时刷题可以暂停想一会儿，可以上网查，周赛不行，你必须连续集中注意力一个半小时，这种高压状态不练是不会自动适应的。但周赛题目的难度普遍比热题 100 的平均难度高，尤其是第三四题，经常涉及较冷门的技巧，做不出来一点不丢人。

我的建议是：把周赛当成“体检”，而不是“主课”。每次做完之后复盘一下，比如这次第一题花了多久、第二题卡在哪一步、第三题涉及的算法我之前见没见过。如果发现某个模式在热题 100 里也出现过但你没能快速识别，那就回到对应的专题去补。我见过有些朋友周赛分数涨了，但面试题还是做不好，原因就是他把精力全放在刷周赛冷门难题上，反而忽略了热题 100 的基础模式，本末倒置了。

5.3 最容易忽略的面试细节

最后这部分说几个刷题之外、但直接影响面试表现的细节，都是我踩过的坑或者见过别人踩的坑。

第一个是手写代码的熟练度。很多面试现在用线上编辑器，但也有不少白板面试和视频面试。如果你习惯了自动补全、语法提示和快速格式化，手写代码时可能会突然发现自己的代码缩进混乱、变量命名随意、甚至写不完整。建议在准备面试前，每天选一两道热题 100 的题目，在纯文本编辑环境下手写一遍，不要求字体漂亮，只要求逻辑完整、接口正确。

第二个是边界条件的“常规安检”。很多人在写题时把主逻辑调通了就万事大吉，等测试用例一跑才发现：空输入没处理、单节点链表没处理、负数和零的情况漏了、数组越界了。热题 100 里很多题的测试用例会专门布置这些陷阱。我自己的习惯是，任何题目写完主逻辑后，立刻在代码开头检查四种情况：空输入、最小规模输入、最大规模输入、全相同输入。这四关过了，大部分隐藏的边界坑都能被提前踩掉。

第三个是沟通表达能力。面试算法题不仅考察你写不写得出来，还考察你能不能边说边写。平时刷题时最好养成习惯：写出思路后，用一句话表达“我打算用什么方法解决，复杂度是多少”，然后边写代码边解释每一步的目的。这需要练习，但练习材料现成的——热题 100 里随便抽一题，你都能对着手机录两三分钟的视频，回看自己表达得是否清楚。

5.4 复盘到最后，留两个实用小技巧

一个是给自己的进度做可视化记录。我建议用一张简单的表格，记录每道题的刷题日期、是否独立完成、用了多长时间、核心思路、错在哪一步。这张表不是为了给别人看，是为了让你自己一眼看出“哪个考点密集出错”“哪类题目前花费时间过长”，从而更精准地决定下一轮把时间花在哪。

另一个是善用题目的“变体练习”。把热题 100 里做过的题稍微改一点条件，看看自己还能不能解。比如腐烂的橘子改成“可以斜着传播”，爱吃香蕉的狒狒改成“每小时可以吃两堆中较小的一堆”，基本计算器改成“加入乘除运算”。不需要真的都写出来，脑子里过一遍思路就行。这样做的价值在于，面试时遇到的原题概率其实不高，但你练习过的“变体适应力”，才是真正让你在不同包装下认出核心套路的底气。