LeetCode热题100刷题指南：从题型套路到面试实战

每年到算法准备的高峰期，总有人拿同一句话来问我：LeetCode刷了三百道，为什么一面试还是挂？我翻过不少人的提交记录，基本都是两种典型情况——要么在冷门难题里死磕到怀疑人生，要么把LeetCode热门100题刷了好几遍，却只会对着原题默写答案，换个说法立刻卡壳。说实话，对于绝大多数正在准备求职、想系统提升算法题感的人来说，热门100题这份题单是性价比远高于盲目刷题的训练材料。这篇总结是我自己刷完三遍、又拿它给几批新人做带练之后沉淀下来的版本，会持续更新，想把题型规律、高频套路、易错点和面试表达一次讲透。

如果你正在准备算法面试，或者处于"刷题很久但没有体系"的阶段，这篇总结就是给你看的。我会先讲清楚这份题单的定位和分布，再按数据结构和算法范式两条主线拆套路，最后把最容易翻车的细节和我自己的刷题节奏分享出来。这里没有"三天精通算法"的捷径，但每一章都是可以直接拿去用的方法。

1. 为什么是热题100：这份题单的真实定位

1.1 它覆盖的是"主城任务"，不是全图探索

很多人对热门100题有一个误解，觉得它是"简单题合集"，刷完也就是图个心理安慰。实际完全不是。热题100的题目来源是新题和经典高频题的交集，基本就是算法面试的抽样调查。你去翻各大公司的面经，会发现考题范围高度集中：数组与哈希、链表、二叉树、动态规划、双指针，轮来轮去就是这些主干知识点。热门100题最大的价值，是把算法面试最常考的 "主城任务" 挑了出来，让你不用在"全图探索"里浪费时间。

打个比方，如果把算法知识比作一座城市，热门100题是城市里的主干道和地标建筑，覆盖的是你到任何一家公司面试都必须经过的主路；而那些竞赛压轴题、偏门冷题，是城市周边的野山路，风景可能很好，但面试时大概率用不上。我见过不少人花大量时间死磕偏难怪题，结果连二叉树的层序遍历都写不利索，这就是主次颠倒的典型。

1.2 题型分布图谱：100题到底在考什么

我自己在二刷的时候，给热题100做了一次细致的题型归类。数据不会骗人，下面是大概的分布情况：

这张表的启发很直接：数组哈希、树图、动态规划加在一起占了六成，刷题的资源就应该往这三块倾斜。链表和双指针看着占比不高，但它们是高频前置技能，很多中等题和困难题都要用。如果时间紧张，栈、队列、堆可以先掌握模板题，回溯和贪心在掌握基础框架后再深入。

另外，热题100里困难题的比例其实是偏高的，大概有三分之一左右。所以刷这份题单时心态要调整好：不需要每道题都独立做出来，能把题解彻底吃透、做到举一反三，就已经达到目的。

2. 数据结构部分的高频套路浓缩

2.1 链表题：三个固定动作解决八成问题

链表题在热题100里数量不算最多，但每道都是面试官的心头好。原因很简单——链表题写代码不难，难的是把指针关系理清楚，而这恰恰最能看出一个人写代码时有没有章法。我总结下来，大多数链表题都能用三个固定动作拆解：虚节点（dummy）、快慢指针、画图走一遍。

第一个动作，虚节点。只要涉及"头节点可能被删除或修改"的题，先加一个 dummy 节点，返回时再看 dummy.next。删除链表的倒数第 N 个结点、反转链表 II 这类题，用虚节点能省掉大量的边界判断，代码可读性也高一个档次。

第二个动作，快慢指针。环形链表和环形链表 II 是快慢指针的经典应用。判断成环很简单：快指针每次两步、慢指针每次一步，两者相遇说明有环。找环入口需要一点数学推导，其实也容易记住：相遇后，让其中一个指针从头节点重新出发，另一个留在相遇点，两边每次都走一步，再次相遇的位置就是环入口。这个结论我在面过几次之后发现自己根本记不牢，于是专门推导了一遍，后来再也没忘——链表题里很多公式，自己推一遍比背十遍都管用。

第三个动作，画图走一遍。有时候两个指针互相倒来倒去，光在脑子里想很容易乱。我在写"反转链表"这类题时，一定会在本子上先把三个节点画出来，标好每一步之后每个指针指向哪里，再落笔写代码。这个方法听起来很基础，但真的能避免"写完了一跑就死循环"的尴尬。

回文链表（234）是个很好的综合题：先用快慢指针找中点，再把后半段反转，之后从头逐一比较。三步都是上面说的固定动作，但组合在一起，就能考出你对链表操作的整体掌控力。热题100里的排序链表（148）也一样，核心是先找中点再归并，找中点用的还是快慢指针。

2.2 二叉树题：递归三要素是唯一正解

二叉树的题目在热题100里少说也有十几道，解法基本都能归到递归三要素：确定递归函数的参数和返回值、确定终止条件、确定单层递归的逻辑。这三要素不是面试八股，而是你写任何递归都要过的三道关。

拿热题100里最简单的二叉树最大深度（104）来说：递归函数返回当前节点的高度；终止条件是节点为空时返回 0；单层逻辑是取左右子树最大高度加一。三步理清楚，代码自然就出来了。这个框架再延伸一下——验证二叉搜索树（98）的中序解法、二叉树的直径（543）的后序解法、把二叉搜索树转换为累加树（538）的反向中序解法，都是同一套逻辑在不同遍历顺序下的应用。

真正让我觉得"通了"的题，是二叉树中的最大路径和（124）。它的核心思路是后续遍历：每次递归返回"经过当前节点能贡献给父路径的最大单边值"，同时在每个节点处更新一个全局最大值，把左子树贡献、右子树贡献和当前节点连起来的完整路径算一遍。这种"子树返回一个值，节点自己更新全局答案"的模式，是二叉树难题的经典套路。理解了它，热题100里很多树形结构题都能顺下来。

还有一个不得不提的是层序遍历（102）。它虽然是广度优先的思路，但实现起来有个小细节需要注意：处理每一层时，先记录当前队列的长度，再循环这么多个节点。如果不记录长度，直接把 level 循环写成 while queue 非空，那队列里加入下一层节点后，当前层就会混在一起。这个细节我在带练时见人踩了无数次，属于"看着简单但一跑就错"的典型。

2.3 栈、队列与单调栈：从"记住结构"到"形成条件反射"

热题100里的栈和队列题不算多，但每一道都值得单独练习。有效的括号（20）是栈的入门题，注意一个小陷阱：如果是 "({[]})" 这种嵌套括号，匹配顺序是后进先出，所以遇到右括号时弹出栈顶判断即可，最后还要检查栈是不是空的。这道题我见过不少人忘了最后一步，结果遇到 "([)]" 这类输入就漏判。

真正有区分度的是单调栈。每日温度（739）是理解单调栈最好的入口：维护一个从栈底到栈顶递减的下标栈，遍历数组时，只要当前温度大于栈顶下标对应的温度，就可以弹出栈顶并计算结果，因为"右边第一个比它大的温度"已经出现了。注意栈里存的是下标而不是温度，这样才能算出隔了多少天。这类"找下一个更大元素"的问题，只要出现"下一个更大/更小"，就应该条件反射地想到单调栈。

队列这边，滑动窗口最大值（239）用的是单调队列，思路和单调栈一脉相承，但多了窗口收缩。当你发现自己在窗口滑动时还要反复找最大值，就该意识到需要用一个双端队列来维护窗口内的候选最大值，队首是当前窗口最大值的下标，每次滑动时先淘汰过期下标，再维护队尾的单调性。把这道题吃透，你对"用额外结构维护窗口信息"的理解会深化不少。

2.4 哈希表：热题100里真正的大赢家

数组与哈希能占四分之一的比例，不是没有原因的。两数之和（1）用哈希表做"边遍历边查找"，是空间换时间的标准示范；字母异位词分组（49）用排序后的字符串当 key，把同构词归到一起；和为 K 的子数组（560）用前缀和加哈希表计数，把 O(n^2) 的枚举压缩到 O(n)。

这三道题放在一起看，能提炼出一个通用的思维模式：当问题需要"快速判断某个值是否出现过"或"快速统计某个前缀信息的出现次数"时，用一个哈希表去记账，几乎总是良配。而且哈希表题最方便练习从暴力解到优化解的"讲故事"过程——面试官就喜欢听你怎么把 O(n^2) 改到 O(n)。

3. 算法范式部分：把题解背成思路

3.1 二分答案的边界哲学：从"爱吃香蕉的狒狒"说起

热题100里并没有"爱吃香蕉的狒狒"这道题，但它在很多人的刷题笔记里被标记为"必刷题单之外必看的补充题"——也就是 LeetCode 875 题 Koko Eating Bananas，网上也常戏称它叫"爱吃香蕉的狒狒"。这道题是理解"二分答案"的最佳素材。

题目不复杂：有一堆香蕉 piles，每个 pile 有一定数量的香蕉，狒狒每小时可以吃掉一堆中的任意 k 根，如果一堆少于 k 根就吃完这堆去下一堆。问在 h 小时内吃完的前提下，最慢的吃香蕉速度 k 是多少。朴素做法是从 1 开始逐个试速度，直到某个速度能在 h 小时内吃完，O(max(piles)·n)，数据一大就超时。

二分答案的关键在于发现单调性：速度 k 越大，完成时间越短。所以我们可以二分 k 本身，把问题变成"给定速度 k，能否在 h 小时内吃完"，也就是写一个 check 函数：

def can_finish(piles, h, speed): hours = 0 for pile in piles: hours += (pile + speed - 1) // speed # 向上取整 if hours > h: return False return True

二分边界我推荐用"左闭右闭"加"答案收敛"的写法，逻辑最不容易出错：

def min_eating_speed(piles, h): left, right = 1, max(piles) while left < right: mid = (left + right) // 2 if can_finish(piles, h, mid): right = mid # 当前速度可以，尝试更慢 else: left = mid + 1 # 当前速度不够快 return left

很多人在二分题上反复翻车，问题几乎都出在边界：mid 用哪种取法、left 和 right 到底谁该跨一步、循环条件是小于还是小于等于。我的经验是，与其记一堆模板，不如每次先想清楚两个问题：check(mid) 满足时答案应该往哪边收敛？check(mid) 不满足时又该往哪边收敛？把这两个问题想明白，边界自然不会再错。向上取整的写法(pile + speed - 1) // speed也是一个高频易错点，直接pile // speed在这道题里会得到错误结果，需要特别注意。

从这道题延伸出去，热题100里的搜索旋转排序数组（33）、在排序数组中查找元素的第一个和最后一个位置（34）也都是二分家族成员，但它们的二分对象是数组下标，判断条件依赖数组本身的单调性或旋转特征。把 "爱吃香蕉的狒狒" 这类"二分答案"练熟之后，再回头写那些下标二分，你会发现自己对边界条件的理解完全不同。

3.2 滑动窗口：什么时候扩张、什么时候收缩

滑动窗口是热题100里最"讲道理"的一类算法题，因为窗口的移动规则是能推理出来的。核心只有三句话：右指针负责扩张窗口，直到窗口不再满足条件；左指针负责收缩窗口，直到窗口重新满足条件；在收缩过程中统计答案。

无重复字符的最长子串（3）是最经典的入门题。用哈希表记录每个字符最后一次出现的下标，右指针向右走时，如果当前字符在窗口内出现过，就把左指针跳到上一次出现位置的后面，然后更新答案。注意这里收缩的是"跳跃式收缩"，比逐步移动左指针更高效。

最小覆盖子串（76）是滑动窗口里比较难的一道，但思路完全一致：右指针扩展，直到窗口内包含了 t 中所有字符；然后尝试收缩左指针，只要窗口仍然包含全部所需字符，就不断收缩并更新最短结果。实现细节上用两个计数器（一个记录 t 中各字符的需求量，一个记录窗口内实际数量），再用一个变量统计"已满足条件的字符种类数"，这会让判断逻辑简单很多。我见过不少人在这里用双重循环去比较两个哈希表，既慢又没必要——维护一个满足种数计数器就能 O(1) 判断。

滑动窗口的题目非常考验细节，尤其是"什么时候更新答案"：是扩张时更新，还是收缩时更新？无重复字符最长子串在扩张时更新即可，最小覆盖子串则必须在收缩时更新。这两类题各做一遍，再遇到"最长xx子串""最短xx子串"就有方向了。

3.3 动态规划：状态定义比转移方程更重要

很多人在热题100的动态规划题上卡住，不是因为不会写转移方程，而是不知道状态该怎么定义。我自己的方法是反过来想：在走到第 i 步时，题目希望我知道什么信息？把这个信息设成状态。

拿打家劫舍（198）来说，走到第 i 家时，有两个可能：偷这一家，那前一家必不能偷；不偷这一家，那前面可以随便偷。于是状态自然分成两种，写成一维的话就是dp[i] = max(dp[i-1], dp[i-2] + nums[i])。这里的dp[i]表示前 i 家能偷到的最大金额。如果一开始想不通，把状态扩展成二维dp[i][0/1]表示"第 i 家不偷/偷"的最大金额，逻辑会更直白。两种定义都能过，面试时选自己讲得最顺的。

爬楼梯（70）则更基础：到第 i 阶可以从 i-1 阶跨一步，也可以从 i-2 阶跨两步，所以dp[i] = dp[i-1] + dp[i-2]，本质就是斐波那契数列。注意大多数面试官会在这个题上追问"能不能优化空间"，所以提前准备好滚动变量的写法非常加分。

零钱兑换（322）是典型的完全背包问题，状态dp[i]表示凑出金额 i 所需的最少硬币数，转移时遍历每种硬币：dp[i] = min(dp[i], dp[i-coin] + 1)。初始化时把dp[0]设为 0，其余设为一个大数。这道题我特别提醒一句：遍历顺序很关键。外层循环遍历金额、内层循环遍历硬币和反过来，结果是一样的，但理解起来前者更直观，建议用一种写死，另一时刻再研究。

最长递增子序列（300）相对难一些，但如果只求长度，可以用贪心加二分：维护一个数组 tails，tails[i] 表示长度为 i+1 的递增子序列的结尾最小值，遍历每个数时二分查找插入位置。这个做法面试中能写出来是加分项，但前提是你要能讲清楚它为什么是对的——不能只背代码。

动态规划题在这个题单里占比不低，我的建议是先把"爬楼梯、打家劫舍、零钱兑换、不同路径、分割等和子集"这五道题吃透，它们分别对应了一维 DP、二维网格 DP、背包 DP 和可行性 DP，覆盖面基本够了。

3.4 回溯算法：一套模板吃透排列组合

回溯在热题100里虽然占比不高，但全排列（46）、组合总和（39）、子集（78）、括号生成（22）这四道题出现频率很高。回溯的核心是"选择、递归、撤销选择"六字口诀，写成模板就是：

def backtrack(path, choices): if 满足结束条件: 记录答案 return for option in choices: 做选择 backtrack(path + [option], 更新后的choices) 撤销选择

关键在"更新后的choices"怎么定。全排列要的是所有顺序，所以每次递归都要从剩余的没用过的数字里选，通常用一个 visited 数组记录是否用过；组合总和不在乎顺序，而且每个数可以重复使用，所以递归时传入一个 startIndex，保证只从当前位置向后取，天然避免重复组合；子集则在整个递归过程中把所有中间路径都记录下来，遇到每个元素都面临"选或不选"。

全排列的去重还有一个很隐蔽的坑：如果输入数组有重复元素，必须先排序，然后在同一层递归中跳过和前一个元素相等的分支。判断条件要写清楚，比如i > start_index and nums[i] == nums[i-1] and not used[i-1]这类逻辑，很多人在这里直接照抄题解，结果不知道为什么，面试一问就露馅。

我个人练回溯题的经验是：先用模板把"无重复全排列"跑通，然后做"组合总和"，观察 startIndex 和 used 数组分别解决什么问题；最后做"子集"，体会什么时候记录答案。三步走完，回溯的套路基本就刻进脑子里了。

4. 热题100里最容易被忽略的易错点

4.1 边界条件：左闭右开、空指针与下标错位

刷热题100的过程里，你会反复遇见三类边界问题。第一类是二分和排序里的左闭右开区间，循环结束时 left 和 right 的关系是什么、mid 会不会越界，不同模板答案不一样，我建议固定使用一种并吃透它。第二类是链表和树里的空指针，reverse 链表时 next 为空、二叉树递归到空节点时该怎么返回，这种位置往往就是空指针异常的爆发点。第三类是数组下标的错位，滑动窗口里左指针是否包含当前字符、和为 K 的子数组里前缀和数组的长度是不是 n+1，这类错误很难靠眼睛看出来，最好在每个边界位置手动代入一个短例子试跑。

我自己的习惯是，每道题写完，立刻在心里跑三个用例：空输入、只有 1 个元素、最大规模输入。这三个用例能帮你在提交前拦下一大半边界问题，比反复提交等判题要高效得多。

4.2 空间复杂度的隐性要求

热题100里不少题都有空间复杂度的隐性约束，最容易踩坑的是那些要求 O(1) 空间的题。移动零（283）要求原地操作，颜色分类（75）要求原地排序，两数之和都能用哈希表通过，但除自身以外数组的乘积（238）明确要求"不使用除法、常数空间"，所以只能做前缀积和后缀积的扫描，最后用输出数组本身来存储中间结果。

寻找重复数（287）是另一道典型的空间陷阱题。题面里给出 n+1 个数都在 1 到 n 之间，要求不能修改数组且只能用常数空间。最自然的想法是哈希表，但空间不达标；排序也不行，因为会修改数组。正确的解法要么用二分值域，要么用快慢指针找环。这种"看着是哈希题，实际是二分/快慢指针题"的弯子，正是热题100里最容易拉开差距的地方。

做这一类题，我建议在动笔前先大声问自己一句：题目有没有隐含的空间限制？没有的话，大胆用哈希表；有的话，优先想想双指针、原地交换和前缀/后缀思想。

4.3 背题解导致的三种"假会做"

我在带练过程中总结过，很多人刷热题100刷到后面会产生三种"假会做"。

第一种是换个数字就不会。热题100的原题背得滚瓜烂熟，但只要把场景换一下、把数组改成字符串、把最大值改成最小值，思路就断掉了。破解办法是每做完一道题，强迫自己把解法讲成一段"为什么这样做"的话，而不是记住"这道题这样做"。

第二种是会写不会说。面试和刷题的最大差别是，面试官会追问"你为什么要想到用单调队列""你的二分边界为什么不会死循环"。如果平时只对着编辑器敲代码，没有口头表达训练，面试现场很难讲清楚。这个问题的解法放在下一章展开。

第三种是忘记复杂度分析。热题100的题解基本都会标时间复杂度和空间复杂度，但很多人根本不看。这会导致你在面试时被问"能不能优化"时完全没方向。我的建议是每道题把复杂度写在代码注释里，不是为了记住数字，而是为了逼自己想一遍"这里循环嵌套了几层、额外开了多大的结构"。

5. 刷题节奏、复盘模板与面试表达训练

5.1 三阶段刷法：从标签刷到乱序刷

热题100总共 100 道，我建议不要平均用力，按三个阶段推进。

第一阶段，按标签刷。先数组哈希，再链表，接着树，然后双指针和滑动窗口，最后动态规划和回溯。标签集中刷的好处是，同一类题连做 5 道之后，套路会自动浮现。这一阶段的目标不是"全部做出来"，而是"每道题都能看懂题解并复现"。

第二阶段，乱序刷。当你有了一定题量，把热题100打乱顺序，每天随机抽 3 到 5 道题，不看标签直接做。这一阶段训练的是"见到问题能自己判断属于哪一类"的能力，也是面试真正需要的。你会发现乱序时有些题就是想不起来用什么思路，这正是好事——暴露了你的薄弱环节。

第三阶段，限时模拟。每道题给自己 25 到 30 分钟，超时就看题解，但看完题解后必须合上题解自己重写一遍。这个阶段的目的是模拟面试的时间压力。很多人平时刷题不卡时间，面试十几分钟写不出来就紧张，所以这种训练很有必要。

三个阶段的用时，我一般是 3:3:2，具体看自己基础调整。基础弱就把第一阶段拉长，刷题经验多就早点进第二阶段。

5.2 复盘模板：让每道题都留下可迁移的资产

刷题不复盘等于白刷。我复盘热题100时，每道题都会在笔记里写下五栏内容：

• 用了什么数据结构，为什么选用它
• 核心算法范式是哪一个（双指针、二分答案、DP、回溯、单调栈等）
• 边界条件里最容易错的地方
• 时间复杂度和空间复杂度
• 这道题能不能抽象成一句更通用的"套路话术"

举个例子，和为 K 的子数组（560）复盘时可以写：数据结构是哈希表，范式是前缀和，易错点是前缀和数组长度和 map 初始值{0:1}，复杂度 O(n)/O(n)，套路话术是"遇到连续子数组求和，优先想前缀和，再想能不能用哈希表压缩查找"。

这些东西攒多了，会在你脑子里形成一张"题路网"。以后看到一道新题，你会下意识地想：这不就是滑动窗口吗？这不就是单调栈的变式吗？这种能力不是凭空来的，就是复盘攒出来的。

5.3 周赛 430 的启示：竞赛与面试题的关系

很多人会问我，平时要不要打周赛。我的回答是：有空就打，但要知道它和面试题的区别。LeetCode 的周赛数据，包括最近的周赛 430 场，都是在核心知识点之外加入了很多组合技巧和更精细的边界处理。竞赛题更看重临场速度和思维强度，而面试题更看重基础功底和沟通能力。打周赛最大的价值，是让你在压力下训练"读题、归类、套模板"的反应速度，这是平时自己慢慢刷题练不出来的。

当然，如果你周赛永远只做得出第一题，也不必气馁。我见过很多人第一题都只能磕磕绊绊过，但热题100刷扎实之后，周赛二三题也能稳定做出来。竞赛是检验，不是目的；热题100才是打底的主线任务。我个人的建议是：热题100三阶段走完再开始系统性打周赛，顺序不要反。

5.4 面试讲题：从"暴力解"到"优化解"的表达路径

面试讲题和私下做出来是两回事。私下里你可以直接写最优解，面试时我更推荐按这个顺序讲：先讲暴力解，把复杂度说清楚；然后指出暴力解的瓶颈；再引出优化思路；最后写最优解并再次完成复杂度分析。

这里的逻辑不是让你多说废话，而是给面试官一个理解你的思考过程的路径。用简单的例子说，求两数之和，暴力解是双重循环，瓶颈在于"每次都要遍历查找另一个数"，于是自然引出哈希表"边遍历边查询"。当你把这个过程讲顺，面试官不仅看出你会做这道题，还会觉得你是一个会思考的人。

讲题时还有几个小技巧：先说结论再解释原因，比如"这题我用二分，因为速度有单调性"；写代码前说边界，比如"注意这里要处理空链表"；写完代码快速手动跟一个短例子，把每一步的状态念出来。这些习惯平时刷题时不练，面试时很难临时发挥出来。

写在最后

这篇 LeetCode 热题100 的总结到目前为止，主要把题型分布、数据结构高频套路、算法范式、易错点和刷题方法讲了一遍，后续我会沿着几个方向继续更新：把每类题的经典变式挑出来做对比串讲，把热题100里容易混淆的成对题目（比如最大子数组和与乘积最大子数组）专门拆开分析，还会把周赛中出现的和热门100题同源的高频竞赛题补充进来。

我自己的体会是，热题100刷得好的标准不是"全都会默写"，而是"看到新题能快速判断它属于哪个套路，并且能在 20 分钟内完成从思路到代码的转化"。这个标准我刷了三遍才勉强达到。刷题这件事没有捷径，但方向对了，确实可以少走很多弯路。如果你按照这篇总结的节奏去刷，我相信四到六周内能看到明显的题感变化。后续更新见。