LeetCode刷题全攻略：从零基础到进阶的系统化方法与实战案例

最近在整理上半年刷题记录时，发现很多朋友在后台留言，希望我能分享一些系统性的刷题方法和实战经验。确实，LeetCode 作为技术面试的“金标准”，其重要性不言而喻，但面对海量题目，如何高效规划、精准突破，是每个开发者都会遇到的难题。本文将结合 2024 年上半年的刷题实践，为你梳理一套从零基础到进阶的完整攻略，涵盖高频考点、解题模板、时间规划以及避坑指南。无论你是准备暑期实习、秋招，还是希望巩固算法基础，都能从中找到可复用的路径。

1. 背景与核心概念：为什么 LeetCode 刷题如此重要？

在当前的软件开发求职市场中，算法与数据结构能力是衡量候选人技术深度的核心标尺之一。LeetCode 平台汇聚了数千道编程题目，覆盖了从数组、字符串到动态规划、图论等几乎所有计算机科学基础领域。它不仅仅是一个“刷题”网站，更是一个模拟真实面试场景、锻炼问题分析与代码实现能力的训练场。

对于开发者而言，系统刷题能带来三大核心价值：

1. 巩固基础知识：很多题目是对经典数据结构（如链表、树、堆）和算法思想（如分治、贪心、回溯）的直接应用，通过解题可以加深理解。
2. 提升编码熟练度与调试能力：在时间限制下完成题目，要求代码一次写对、边界清晰，这极大地锻炼了编码的严谨性和自测（Debug）能力。
3. 熟悉面试套路与思维模式：大厂面试题很多源于或改编自 LeetCode，熟悉常见题目的变种和解题思路，能在面试中更快地切入问题核心。

然而，盲目刷题往往事倍功半。常见的误区包括：只追求题目数量而忽视总结；遇到难题直接看答案，缺乏独立思考；没有分类规划，知识点零散。本文将致力于解决这些问题，提供一套可执行的系统化方案。

2. 环境准备与版本说明

工欲善其事，必先利其器。一个高效的刷题环境能让你更专注于算法本身。

2.1 编程语言选择

选择一门你最为熟悉、且在面试中允许使用的语言。主流选择有：

• Python：语法简洁，内置数据结构强大（如列表、字典、集合），在实现算法时往往代码量更少，适合快速原型验证。是当前非常流行的刷题语言。
• Java：强类型语言，代码结构清晰，企业级开发中使用广泛。需要注意其标准库的使用（如PriorityQueue,HashMap）。
• C++：执行效率高，适合对性能有极致要求的题目，但语法相对复杂。
• JavaScript：前端开发者的首选，需要注意运行环境差异。

建议：选定一门后，在整个刷题周期内尽量保持统一，以深化对该语言特性和标准库的掌握。

2.2 集成开发环境（IDE）或编辑器

• 本地 IDE：PyCharm (Python), IntelliJ IDEA (Java), VS Code (全语言支持) 都是优秀的选择。它们提供代码补全、调试、版本控制集成等功能。
• 在线平台：LeetCode 官网自带的代码编辑器已足够好用，支持运行和调试。对于想保存本地代码或进行版本管理的同学，可以配合本地编辑器使用。

2.3 辅助工具与习惯

• 代码版本管理：在本地为 LeetCode solutions 建立一个 Git 仓库，按题目分类存放，便于回顾和总结。
• 笔记工具：准备一个笔记本（或使用 Notion、语雀等在线工具），用于记录每道题的核心思路、易错点、时间/空间复杂度分析以及一题多解。
• 调试技巧：熟练掌握在 IDE 中设置断点、单步执行、查看变量状态的方法。对于在线平台，善用print语句或console.log进行输出调试。

版本说明：本文的代码示例将主要使用Python 3进行演示，因为其可读性强，易于理解算法逻辑。其他语言的思路完全相通，你可以自行转换。

3. 核心知识点与解题模板拆解

盲目刷题不如有效归类。掌握每一类题目的通用解题框架，能让你在遇到新题时快速定位思路。

3.1 数组与字符串：双指针与滑动窗口

这是最基础也是最常考的类型。

双指针：常用于有序数组的去重、找两数之和、合并有序数组等场景。

# 示例：移除有序数组中的重复项（LeetCode 26） def removeDuplicates(nums): if not nums: return 0 slow = 0 # 慢指针，指向下一个唯一元素应该放置的位置 for fast in range(1, len(nums)): # 快指针，遍历整个数组 if nums[fast] != nums[slow]: slow += 1 nums[slow] = nums[fast] return slow + 1 # 新数组的长度 # 核心思想：快指针探索，慢指针构建结果。

滑动窗口：用于解决子串、子数组的相关问题，如“长度最小的子数组”、“无重复字符的最长子串”。

# 示例：长度最小的子数组（LeetCode 209） def minSubArrayLen(target, nums): left = 0 current_sum = 0 min_length = float('inf') for right in range(len(nums)): current_sum += nums[right] # 扩大窗口 while current_sum >= target: # 满足条件时，尝试收缩窗口 min_length = min(min_length, right - left + 1) current_sum -= nums[left] left += 1 # 收缩窗口 return min_length if min_length != float('inf') else 0 # 核心思想：用左右指针维护一个窗口，通过移动右指针扩大窗口，移动左指针收缩窗口，在窗口满足条件时更新答案。

3.2 链表：虚拟头节点与快慢指针

链表问题常涉及节点的增删改查，技巧性较强。

虚拟头节点（Dummy Node）：可以简化对头节点的特殊处理，尤其是在需要删除头节点时。

# 示例：删除链表的倒数第 N 个结点（LeetCode 19） class ListNode: def __init__(self, val=0, next=None): self.val = val self.next = next def removeNthFromEnd(head, n): dummy = ListNode(0, head) # 创建虚拟头节点，指向原链表头 fast = slow = dummy # 快指针先走 n+1 步 for _ in range(n + 1): fast = fast.next # 快慢指针同步前进，直到快指针到达末尾 while fast: fast = fast.next slow = slow.next # 此时 slow 指向待删除节点的前一个节点 slow.next = slow.next.next return dummy.next # 返回新的头节点

快慢指针：除了找倒数第N个节点，还常用于判断链表是否有环、找环的入口。

# 判断链表是否有环（LeetCode 141） def hasCycle(head): if not head or not head.next: return False slow = head fast = head.next while slow != fast: if not fast or not fast.next: # 快指针走到头了，说明无环 return False slow = slow.next fast = fast.next.next return True # 快慢指针相遇，说明有环

3.3 二叉树：递归与迭代遍历

二叉树的题目几乎都建立在遍历的基础上。

递归遍历（前、中、后序）：代码简洁，易于理解，是基础。

# 二叉树节点定义 class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right # 递归中序遍历 def inorderTraversal(root): result = [] def dfs(node): if not node: return dfs(node.left) # 左 result.append(node.val) # 中 dfs(node.right) # 右 dfs(root) return result

迭代遍历（使用栈）：面试中常要求掌握，以避免递归栈溢出的问题。

# 迭代中序遍历（使用栈模拟） def inorderTraversalIterative(root): result = [] stack = [] cur = root while cur or stack: # 一路向左，将节点入栈 while cur: stack.append(cur) cur = cur.left # 弹出栈顶节点（此时是最左边的节点） cur = stack.pop() result.append(cur.val) # 转向右子树 cur = cur.right return result

3.4 动态规划（DP）：识别状态与转移方程

动态规划是难点，但套路相对固定。核心是定义dp数组的含义，并找出状态转移方程。

解题步骤模板：

1. 定义 dp 数组：dp[i]或dp[i][j]代表什么？
2. 确定初始状态：dp[0]或dp[0][0]等边界情况的值。
3. 推导状态转移方程：如何从已知状态推导出dp[i][j]？
4. 确定遍历顺序。
5. 举例推导，验证正确性。

# 示例：爬楼梯（LeetCode 70） def climbStairs(n): if n <= 2: return n # 1. 定义dp数组：dp[i]表示爬到第i阶楼梯的方法数 dp = [0] * (n + 1) # 2. 确定初始状态 dp[1] = 1 dp[2] = 2 # 3. 状态转移方程：dp[i] = dp[i-1] + dp[i-2] # 4. 遍历顺序：从3到n for i in range(3, n + 1): dp[i] = dp[i-1] + dp[i-2] return dp[n] # 空间优化版（滚动数组） def climbStairs_opt(n): if n <= 2: return n a, b = 1, 2 # a代表dp[i-2], b代表dp[i-1] for i in range(3, n + 1): a, b = b, a + b # 新的b就是dp[i] return b

4. 2024年刷题实战规划与案例精讲

有了基础知识，我们需要一个科学的刷题计划。建议分为三个阶段，周期约为3-4个月。

4.1 第一阶段：基础夯实（约1个月）

目标：掌握数据结构的基本操作和简单算法。每日任务：5-10题（Easy为主，少量Medium）。重点专题：数组、字符串、链表、二叉树、栈、队列、哈希表。方法：按专题刷，每个专题刷15-20道经典题，务必理解并默写核心代码。

实战案例：LeetCode 1. 两数之和这是哈希表应用的入门经典题。

def twoSum(nums, target): """ :type nums: List[int] :type target: int :rtype: List[int] """ hash_map = {} # 字典，用于存储值到索引的映射 for i, num in enumerate(nums): complement = target - num if complement in hash_map: # 检查补数是否已在字典中 return [hash_map[complement], i] # 找到，返回索引 hash_map[num] = i # 没找到，将当前数字和索引存入字典 return [] # 题目保证有解，这行不会执行 # 思路解析： # 暴力法是两层循环，O(n^2)。利用哈希表，我们可以在O(1)时间内查找“需要的另一个数”是否出现过。 # 遍历数组，对于每个数nums[i]，计算它需要的“另一半” complement = target - nums[i]。 # 如果complement已经在哈希表中，说明我们找到了配对。 # 否则，将当前数nums[i]及其索引i存入哈希表，供后续数字查找。 # 时间复杂度O(n)，空间复杂度O(n)。

4.2 第二阶段：算法强化（约1.5个月）

目标：攻克中等难度题目，掌握核心算法思想。每日任务：3-5题（Medium为主）。重点专题：深度优先搜索（DFS）、广度优先搜索（BFS）、回溯、贪心、动态规划、二分查找。方法：继续按专题刷，对于DP、回溯等难点，可以配合图解和视频理解，并总结自己的解题模板。

实战案例：LeetCode 200. 岛屿数量（DFS/BFS）这是二维矩阵DFS/BFS遍历的典型应用。

# DFS 解法 def numIslands(grid): if not grid: return 0 rows, cols = len(grid), len(grid[0]) count = 0 def dfs(r, c): # 递归终止条件：越界或不是陆地 if r < 0 or r >= rows or c < 0 or c >= cols or grid[r][c] != '1': return # 将访问过的陆地标记为‘0’（即“淹没”） grid[r][c] = '0' # 向四个方向深度搜索 dfs(r+1, c) dfs(r-1, c) dfs(r, c+1) dfs(r, c-1) for r in range(rows): for c in range(cols): if grid[r][c] == '1': # 发现一块新陆地 count += 1 dfs(r, c) # 用DFS“淹没”整个相连的岛屿 return count # 思路解析： # 核心是“沉没”思想。遍历整个网格，当遇到一块陆地（‘1’），岛屿计数+1。 # 然后通过DFS或BFS，将这块陆地以及与其上下左右相连的所有陆地都标记为已访问（例如改为‘0’）。 # 这样，后续遍历就不会再重复计数这些相连的陆地了。 # 时间复杂度 O(M*N)，其中M和N是网格的行数和列数。

4.3 第三阶段：冲刺与模拟（约1个月）

目标：刷高频题、难题，并进行限时模拟。每日任务：2-3题（Medium-Hard），每周进行一次2小时的全套模拟面试。重点：LeetCode Hot 100，剑指 Offer，以及近期周赛题目。方法：不再按专题，而是打乱顺序刷，锻炼随机应变能力。严格计时，模拟真实面试环境。

实战案例：LeetCode 73. 爱吃香蕉的狒狒（二分查找）这是一道典型的二分查找应用题，关键在于将问题转化为“判断条件”。

def minEatingSpeed(piles, h): """ :type piles: List[int] :type h: int :rtype: int """ # 狒狒吃香蕉的速度范围：最小是1，最大是香蕉堆中的最大值（再大也没意义） left, right = 1, max(piles) # 辅助函数：计算以速度k吃完所有香蕉需要的小时数 def hours_needed(k): total_hours = 0 for pile in piles: total_hours += (pile + k - 1) // k # 向上取整的巧妙写法 return total_hours # 二分查找最小的满足条件的速度k while left < right: mid = (left + right) // 2 if hours_needed(mid) <= h: # 如果当前速度mid能在h小时内吃完，尝试更小的速度 right = mid else: # 当前速度太慢，需要加快速度 left = mid + 1 return left # 此时left == right，即为最小速度 # 思路解析： # 暴力法是从1到max(piles)依次尝试，但会超时。 # 注意到：吃香蕉的速度k越大，所需时间越少，这是一个单调关系。 # 因此，我们可以用二分查找来快速定位“能在h小时内吃完香蕉的最小速度k”。 # 二分查找的“判断条件”是：计算以速度k吃完所有香蕉需要的时间total_hours。 # 如果total_hours <= h，说明速度k可行，但我们还想试试更小的速度（收缩右边界）。 # 如果total_hours > h，说明速度k太慢，需要加大速度（收缩左边界）。 # 时间复杂度 O(N log M)，其中N是堆数，M是最大堆的香蕉数。

5. 常见问题与排查思路

在刷题过程中，你一定会遇到各种“坑”。下面是一些高频问题及解决方案。

6. 最佳实践与工程建议

将刷题视为一个工程项目来管理，能极大提升效率和效果。

6.1 代码规范与可读性

• 命名规范：变量名、函数名要见名知意。slow,fast比i,j更能体现双指针的意图；dp比f更能表明是动态规划数组。
• 注释关键步骤：在复杂的逻辑处（如状态转移、指针移动条件）添加简短注释，方便自己回顾和他人理解。
• 函数单一职责：一个函数最好只做一件事。例如，把计算所需时间的逻辑抽成hours_needed(k)函数，使主逻辑更清晰。

6.2 总结与复盘体系

• 一题多解：对于经典题目，尝试用不同方法解决。例如“两数之和”，除了哈希表，思考是否可以用排序+双指针（如果返回的是值而不是索引）。
• 归纳模板：将同一类题目的解法抽象成模板。例如，滑动窗口的代码框架、二叉树迭代遍历的栈操作顺序、回溯法的递归框架。
• 错题本：建立一个错题集，记录第一次没做出来或做错的题目。定期（如每周）回顾，分析当时卡壳的原因。
• 复杂度分析：养成习惯，对每个解法都分析其时间复杂度和空间复杂度，并思考是否有优化空间。

6.3 模拟面试与时间管理

• 限时练习：平时练习就给自己计时（Easy 15-20分钟，Medium 25-30分钟，Hard 40-50分钟），培养时间感。
• 白板编程：偶尔尝试在纸上或纯文本编辑器里写代码，锻炼在没有自动补全和语法高亮下的编码能力。
• 口述思路：在写代码前，先尝试用语言清晰地描述解题步骤。这能锻炼你在面试中沟通的能力。
• 定期回顾：不要一味追求新题。每周留出时间，快速重做之前做过的经典题和错题，巩固记忆。

6.4 心态与节奏

• 保持节奏：每天坚持刷1-3题，比周末突击刷20题效果更好。
• 不畏难题：遇到Hard题，即使想不出来，认真思考半小时再看题解，收获也比直接看答案大得多。
• 善用资源：LeetCode讨论区、官方题解、优质技术博客都是很好的学习资源，但核心是内化成自己的知识。
• 目标导向：如果是为了面试，后期应聚焦于目标公司的高频题和经典题。如果是为了竞赛，则需要涉猎更广、钻研更深。

刷题是一场马拉松，而非冲刺。它考验的不仅是智力，更是毅力、方法和习惯。通过2024年这半年的系统实践，最大的感悟是：刷题的本质是思维训练。数量的积累固然重要，但更重要的是通过每一道题，加深对某个数据结构或算法思想的理解，并形成肌肉记忆。当你看到新题能迅速联想到归类和方法时，你就已经成功了。从现在开始，制定你的计划，拿起笔和键盘，一道题一道题地攻克，你会在未来的某个时刻，感谢今天开始行动的自己。