LeetCode Hot 100高效刷题技巧与实战指南

1. LeetCode Hot 100 高效刷题方法论

作为一名经历过校招季的算法工程师，我深知LeetCode Hot 100在技术面试中的分量。这份题目清单汇集了各大科技公司的高频考题，但很多人在刷题过程中容易陷入"刷了就忘"的困境。本文将分享我总结的17个实战技巧，帮助你在3周内系统攻克Hot 100，建立长效解题思维。

2. 刷题前的战略准备

2.1 题目分类与优先级规划

Hot 100涵盖六大核心题型：数组/字符串（32%）、动态规划（18%）、链表（12%）、二叉树（15%）、回溯（10%）和其他（13%）。建议按以下顺序攻坚：

1. 数组/字符串（3天）
2. 双指针技巧（2天）
3. 滑动窗口（2天）
4. 二叉树遍历（2天）
5. 动态规划（4天）
6. 回溯算法（2天）
7. 剩余题型（2天）

2.2 工具链配置

推荐使用VS Code + LeetCode插件组合：

# 安装leetcode-cli npm install -g leetcode-cli # 登录账号 leetcode user -l

配置.vscode/settings.json：

{ "leetcode.workspaceFolder": "./algorithms", "leetcode.defaultLanguage": "python3" }

3. 核心解题技巧详解

3.1 数组类题目三板斧

对于高频的数组/字符串问题（如#1两数之和、#15三数之和），掌握这三个技巧可解决80%问题：

1. 哈希映射速查法：用字典存储遍历过的元素，将O(n²)暴力解优化为O(n)

def twoSum(nums, target): hashmap = {} for i, num in enumerate(nums): if target - num in hashmap: return [hashmap[target - num], i] hashmap[num] = i

2. 双指针夹逼法：处理有序数组时，左右指针向中间收敛

def threeSum(nums): nums.sort() res = [] for i in range(len(nums)-2): if i > 0 and nums[i] == nums[i-1]: continue l, r = i+1, len(nums)-1 while l < r: s = nums[i] + nums[l] + nums[r] if s < 0: l += 1 elif s > 0: r -= 1 else: res.append([nums[i], nums[l], nums[r]]) while l < r and nums[l] == nums[l+1]: l += 1 while l < r and nums[r] == nums[r-1]: r -= 1 l += 1; r -= 1 return res

3. 滑动窗口模板：解决子数组/子串问题（如#3无重复字符的最长子串）

def lengthOfLongestSubstring(s): char_index = {} left = max_len = 0 for right, char in enumerate(s): if char in char_index and char_index[char] >= left: left = char_index[char] + 1 char_index[char] = right max_len = max(max_len, right - left + 1) return max_len

3.2 动态规划破题四步法

以#70爬楼梯为例，DP问题的通用解法：

1. 定义状态：dp[i]表示到第i阶的方法数
2. 状态转移：dp[i] = dp[i-1] + dp[i-2]
3. 初始条件：dp[0]=1, dp[1]=1
4. 空间优化：用滚动数组将O(n)空间降为O(1)

def climbStairs(n): if n <= 2: return n a, b = 1, 2 for _ in range(3, n+1): a, b = b, a + b return b

关键提示：遇到"最值"、"方案数"问题时，优先考虑DP解法。背包问题要区分01背包和完全背包的状态转移差异。

4. 高频题型专项突破

4.1 二叉树遍历的三种姿势

以#94二叉树的中序遍历为例，必须掌握：

1. 递归法（面试时需说明时空复杂度）

def inorderTraversal(root): res = [] def dfs(node): if not node: return dfs(node.left) res.append(node.val) dfs(node.right) dfs(root) return res

2. 迭代法（显示栈模拟递归）

def inorderTraversal(root): res, stack = [], [] curr = root while curr or stack: while curr: stack.append(curr) curr = curr.left curr = stack.pop() res.append(curr.val) curr = curr.right return res

3. Morris遍历（O(1)空间技巧）

def inorderTraversal(root): res = [] curr = root while curr: if not curr.left: res.append(curr.val) curr = curr.right else: pre = curr.left while pre.right and pre.right != curr: pre = pre.right if not pre.right: pre.right = curr curr = curr.left else: pre.right = None res.append(curr.val) curr = curr.right return res

4.2 链表问题快慢指针技巧

处理#141环形链表、#19删除链表的倒数第N个结点等问题时：

def hasCycle(head): slow = fast = head while fast and fast.next: slow = slow.next fast = fast.next.next if slow == fast: return True return False def removeNthFromEnd(head, n): dummy = ListNode(0, head) slow = fast = dummy for _ in range(n): fast = fast.next while fast.next: slow = slow.next fast = fast.next slow.next = slow.next.next return dummy.next

5. 刷题效率提升策略

5.1 错题本管理方案

建立结构化错题记录：

| 题号 | 错误原因 | 正确解法要点 | 相似题目 | |------|------------------------|-----------------------|----------------| | #42 | 没考虑双指针移动条件 | 左右最大值中的较小值 | #11, #407 | | #53 | 分治终止条件错误 | 跨中点情况处理 | #152, #918 |

5.2 时间管理番茄工作法

采用45分钟专注刷题+15分钟复盘的方式：

1. 前5分钟：阅读题目并构思解法
2. 15分钟：编写代码并通过示例测试
3. 10分钟：处理边界条件和优化
4. 15分钟：对比优秀题解并做笔记

5.3 模拟面试实战训练

随机抽取Hot 100题目，使用以下流程：

1. 5分钟：口头阐述解题思路
2. 15分钟：白板编码（用https://excalidraw.com/模拟）
3. 5分钟：复杂度分析和测试用例设计

6. 进阶技巧与资源推荐

6.1 空间复杂度优化技巧

以#198打家劫舍为例，展示如何将O(n)空间优化到O(1)：

def rob(nums): prev_max = curr_max = 0 for num in nums: temp = curr_max curr_max = max(prev_max + num, curr_max) prev_max = temp return curr_max

6.2 可视化调试工具

推荐使用Python Tutor（http://pythontutor.com/）逐步观察：

1. 链表指针变化
2. 递归调用栈
3. 矩阵遍历顺序

6.3 扩展学习资料

1. 《算法导论》重点章节：分治、DP、图算法
2. LeetCode官方出品的《图解算法数据结构》
3. 代码随想录（https://programmercarl.com/）的题型分类

7. 常见陷阱与避坑指南

7.1 边界条件检查清单

遇到以下情况要特别小心：

• 空输入（空数组、空字符串）
• 单元素/双元素特殊情况
• 整数溢出（Python无此问题但其他语言需注意）
• 指针类题目中的头/尾节点处理

7.2 调试技巧三板斧

1. 打印关键变量：在循环/递归中打印中间状态
2. 小黄鸭调试法：向他人（或玩偶）逐行解释代码
3. 极端测试用例：构造最小和最大规模的输入验证

7.3 代码风格规范

1. 变量命名体现语义（如slow/fast指针）
2. 添加关键注释说明算法步骤
3. 保持一致的缩进和空行（PEP8标准）
4. 提前处理明显边界条件

8. 个人实战心得

在刷完三遍Hot 100后，我总结出这些经验：

1. 每道题至少用两种解法实现（如递归+迭代）
2. 对于DP问题，先写暴力解再优化
3. 每周参加LeetCode周赛检验实战能力
4. 建立自己的代码模板库（如二分查找模板）
5. 遇到难题时，先手动画图理清思路

最后推荐用Notion搭建刷题进度看板，包含以下视图：

• 按题型分类的完成情况
• 重做次数统计
• 每日刷题记录
• 面试高频题标记