LeetCode热门100 on 奇伏禾

LeetCode 热门 100 题全模块总结：数据结构与算法的系统化思维

Fri, 24 Jul 2026 00:00:00 +0000

一、前言

经过前面 11 个模块、15 篇文章的系统学习，我们已经完成了 LeetCode 热门 100 题的全覆盖。从最基础的哈希表到最复杂的多维动态规划，从线性的数组链表到非线性的图论和回溯，每一道题都对应一种特定的算法思想或数据结构技巧。

本文旨在对全部模块进行 横向对比与纵向串联，帮助你在脑海中形成一张完整的"算法知识图谱"。当遇到新题目时，能够快速匹配到对应的解题范式。

二、算法模块全景图

LeetCode 热门 100 题的算法模块可以按照 数据结构 和 算法思想 两个维度进行分类：

按数据结构分类

模块	核心数据结构	代表题目
哈希表	HashMap / HashSet	两数之和、字母异位词分组、最长连续序列
栈	Deque（ArrayDeque）	有效的括号、最小栈、字符串解码、每日温度
堆（优先队列）	PriorityQueue	第K大元素、前K高频元素、数据流中位数
链表	ListNode（自定义）	反转链表、环形链表、合并链表、LRU缓存
二叉树	TreeNode（自定义）	中序遍历、最大深度、对称二叉树、最近公共祖先
前缀树	TrieNode（自定义）	实现 Trie（208）
矩阵/二维数组	int[][]	矩阵置零、螺旋矩阵、旋转图像、搜索二维矩阵
图（邻接表）	List[]	课程表（拓扑排序）

按算法思想分类

模块	核心思想	代表题目
双指针	同向/相向指针遍历	移动零、盛最多水、三数之和、接雨水
滑动窗口	双指针维护动态区间	无重复字符最长子串、字母异位词、最小覆盖子串
二分查找	不断缩小搜索区间	搜索插入位置、旋转数组、两数组的中位数
回溯	选择-探索-撤销（DFS+剪枝）	子集、全排列、N皇后、单词搜索
贪心	每一步局部最优 → 全局最优	划分字母区间
动态规划	重叠子问题 + 状态转移	爬楼梯、打家劫舍、零钱兑换、最长递增子序列
多维DP	二维及以上状态表	不同路径、最长公共子序列、编辑距离
图论	DFS/BFS / 拓扑排序 / 并查集	岛屿数量、腐烂的橘子、课程表
特殊技巧	数学性质 / 位运算 / 链表判圈	只出现一次的数字、多数元素、颜色分类、寻找重复数

三、时间复杂度与空间复杂度全景对比

下表是对 11 大模块中 每一类核心操作 的时间与空间复杂度的全景汇总。

3.1 数据结构操作复杂度

数据结构	核心操作	时间复杂度	空间复杂度	备注
哈希表	查找 / 插入 / 删除	O(1) 平均	O(n)	最坏 O(n) 哈希碰撞
栈	入栈 / 出栈 / 取栈顶	O(1)	O(n)	严格 O(1) 操作
堆（优先队列）	插入（offer）	O(log n)	O(n)	堆化操作
堆（优先队列）	删除堆顶（poll）	O(log n)	O(n)	下沉调整
堆（优先队列）	取堆顶（peek）	O(1)	O(1)	—
链表	查找/访问	O(n)	O(n)	不支持随机访问
链表	插入/删除（已知位置）	O(1)	O(1)	需先遍历到目标
二叉树	遍历（DFS/BFS）	O(n)	O(h)	h 为树高
前缀树	插入 / 搜索	O(L)	O(26×N×L)	L 为字符串长度
矩阵	遍历	O(mn)	O(1)	额外空间取决于算法

3.2 算法复杂度对比

算法模块	最佳时间复杂度	最差时间复杂度	空间复杂度	适用数据规模
暴力枚举	O(n)	O(n!)	O(1)	n ≤ 20
双指针	O(n)	O(n²)（三数之和）	O(1)	很大
滑动窗口	O(n)	O(n)	O(k)	很大
二分查找	O(log n)	O(log n)	O(1)	极大
回溯	O(n·2^n) ~ O(n!)	O(n!) ~ O(n·n!)	O(n)	n ≤ 15~20
贪心	O(n)	O(n log n)	O(1) ~ O(n)	很大
动态规划（一维）	O(n)	O(n²)	O(n) → O(1) 可优化	n ≤ 10⁵
多维DP	O(mn)	O(n³)	O(mn) → O(n) 可优化	维度数决定
图论 DFS/BFS	O(V+E)	O(V+E)	O(V)	中等
图论拓扑排序	O(V+E)	O(V+E)	O(V+E)	中等
图论并查集	O(α(n))	O(α(n))	O(n)	极大（α为反阿克曼函数）

3.3 LeetCode 热门 100 题中各模块时间复杂度速查

模块	代表题	最优解法	时间复杂度	空间复杂度
哈希表	两数之和	哈希表	O(n)	O(n)
哈希表	最长连续序列	HashSet + 起点延伸	O(n)	O(n)
双指针	盛最多水的容器	左右指针（相向）	O(n)	O(1)
双指针	三数之和	排序 + 双指针	O(n²)	O(1)
双指针	接雨水	左右指针（维护最高）	O(n)	O(1)
滑动窗口	无重复最长子串	哈希集合 + 窗口	O(n)	O(k)
滑动窗口	最小覆盖子串	频次计数 + 窗口	O(n+m)	O(k)
二分查找	搜索旋转数组	二分 + 有序区间判定	O(log n)	O(1)
二分查找	两数组中位数	二分较短的数组	O(log min(m,n))	O(1)
回溯	子集	`start` 控制递归	O(n·2^n)	O(n)
回溯	N 皇后	列+对角线剪枝	O(n!)	O(n²)
贪心	划分字母区间	最后位置 + 边界切分	O(n)	O(1)
动态规划	爬楼梯	一维 DP	O(n)	O(1)
动态规划	零钱兑换	完全背包 DP	O(amount·n)	O(amount)
动态规划	最长递增子序列	DP + 二分优化	O(n log n)	O(n)
多维DP	不同路径	二维DP / 滚动数组	O(mn)	O(n)
多维DP	编辑距离	二维DP / 滚动数组	O(mn)	O(n)
栈	柱状图最大矩形	单调栈 + 哨兵	O(n)	O(n)
栈	字符串解码	双栈（数字+字符串）	O(n·maxK)	O(n)
堆	第K大元素	小顶堆（大小k）	O(n log k)	O(k)
堆	数据流中位数	双堆（大顶+小顶）	O(log n) 插入	O(n)
数组/技巧	最大子数组和	Kadane 算法	O(n)	O(1)
数组/技巧	缺失第一个正数	原地哈希	O(n)	O(1)
矩阵	矩阵置零	第一行/列作标记	O(mn)	O(1)
矩阵	搜索二维矩阵 II	Z字形搜索	O(m+n)	O(1)
链表	环入口	快慢指针	O(n)	O(1)
链表	排序链表	归并排序（自底向上）	O(n log n)	O(1)
图论	岛屿数量	DFS/BFS 染色	O(mn)	O(mn)
图论	课程表	拓扑排序（Kahn）	O(V+E)	O(V+E)

四、算法选择心法：遇到新题怎么想？

4.1 问题特征 → 算法映射

当你在面试或刷题中遇到一个新问题时，可以按照以下思路快速定位解法：

输入特征                          → 优先考虑的算法
──────────────────────────────────────────────────
数据规模 n ≤ 20                   → 回溯 / 状态压缩
数据规模 n ≤ 1000                 → O(n²) 可接受（DP、暴力）
数据规模 n ≤ 10⁵                 → O(n log n)（排序、二分、堆）
数据规模 n ≤ 10⁶+                → O(n) 或 O(1)（哈希、贪心、双指针）

需找"最长/最短子串"              → 滑动窗口
需找"子数组和=target"            → 前缀和 + 哈希
需找"第K大/小"                  → 堆 / 快速选择
有序数组 / 部分有序              → 二分查找
需枚举所有排列/组合/子集          → 回溯
需找最值，且子问题重叠            → 动态规划
每步局部最优 → 全局最优           → 贪心（需证明）
图/树/网格连通性                 → DFS / BFS
依赖关系 / 课程安排              → 拓扑排序
成对元素 / 匹配                 → 栈 / 哈希表
原地操作 / O(1)空间              → 双指针 / 原地哈希

4.2 复杂度渐进关系速记

O(1) < O(log n) < O(n) < O(n log n) < O(n²) < O(2ⁿ) < O(n!)

10⁶  → O(n) 或 O(n log n)   ✅ 可行
10⁴  → O(n²)                ✅ 可行
10²  → O(n³)                ⚠️ 勉强
20   → O(2ⁿ) / O(n!)        ⚠️ 剪枝后可过

五、各模块核心心法速记

哈希表

“用空间记录历史，避免未来重复查找。” 核心能力：O(1) 的存在性查询。适合求和、配对、去重、计数、归类。

双指针

“一次遍历代替嵌套循环，O(1) 空间优化 O(n²) 时间。” 核心能力：同向（快慢）用于原地修改，相向（左右）用于有序数组配对和最值。

滑动窗口

“右指针扩张找可行解，左指针收缩找最优解。” 核心能力：子串/子数组问题的 O(n) 利器，配合频次计数器。

二分查找

“不断缩小搜索区间，排除不可能的一半。” 核心能力：O(log n) 在有序或部分有序空间中精确定位。

回溯

“选择 → 递归 → 撤销。暴力穷举 + 剪枝。” 核心能力：排列、组合、子集、分割、棋盘问题的通用模板。

贪心

“每步局部最优，累积出全局最优。” 核心能力：需要证明贪心选择性质，常用于区间、调度、边界类问题。

动态规划

“定义状态 → 转移方程 → 初始化 → 填表顺序 → 返回结果。” 核心能力：多阶段决策最优解，用空间换时间避免重复计算。

栈

“LIFO 保存等待处理的状态。匹配、回溯、单调栈三大场景。” 核心能力：括号匹配、嵌套解码、下一个更大元素、最大矩形面积。

堆

“动态极值容器。小顶堆保留 TopK，大顶堆保留 BottomK。” 核心能力：O(log n) 插入 + O(1) 获取极值，适合数据流和 TopK。

链表

“指针操作的艺术。虚拟头结点 + 双指针 + 递归。” 核心能力：反转、合并、环检测、随机复制、归并排序。

矩阵

“将二维操作转化为一维或常量操作。” 核心能力：原地标记、边界收缩、转置+翻转、单调性搜索。

图论

“状态传播（DFS/BFS）、依赖顺序（拓扑排序）、字符串查找（Trie）。” 核心能力：连通性检测、层数传播、环检测、前缀匹配。

六、学习路线建议

第一阶段：基础数据结构（1~2 周）

数组与字符串：双指针、滑动窗口、前缀和
链表：反转、合并、快慢指针、环检测
栈与队列：括号匹配、单调栈、最小栈

第二阶段：核心算法思想（2~3 周）

哈希表：两数之和系列、分组、连续序列
二叉树：遍历框架、递归分解、BST、路径和
堆：TopK、前K高频、中位数
二分查找：边界查找、旋转数组、双数组

第三阶段：进阶算法（3~4 周）

回溯：子集、组合、排列、分割、N皇后
动态规划（一维）：线性DP、背包DP、子序列DP
多维DP：网格路径、双序列匹配、编辑距离
图论：DFS/BFS、拓扑排序、Trie

第四阶段：综合与技巧（持续）

矩阵专题：原地标记、螺旋遍历、旋转
贪心与技巧：摩尔投票、荷兰国旗、Floyd判圈
混合应用：前缀树+回溯（单词搜索 II）、堆+分治（395题）

七、写在最后

算法学习没有捷径，但有方法论。LeetCode 热门 100 题之所以"热门"，正是因为它们覆盖了面试中最常考的算法模型和数据结构。吃透这 100 道题，意味着你掌握了：

11 种算法思想（枚举、双指针、滑动窗口、二分、回溯、贪心、DP、分治、拓扑、并查集、位运算）
8 种数据结构（数组、链表、栈、队列、哈希表、树、堆、图）
3 种优化思路（空间换时间、状态复用、单调性剔除）

“刷题不在多，在于精。精在于总结，在于归纳，在于形成条件反射。”

当你看到"连续子数组"想到前缀和，看到"子串"想到滑动窗口，看到"第K大"想到堆，看到"所有可能"想到回溯，看到"最值"想到 DP — 你就完成了从"刷题"到"解题"的蜕变。

祝你在 Java 后端开发与算法面试的道路上越走越远！🚀

动态规划模块 — LeetCode 热门 100 题精讲（Java 向）

Thu, 23 Jul 2026 00:00:00 +0000

动态规划核心思想

动态规划（Dynamic Programming，DP）是解决多阶段决策问题的最优化方法。其核心是 将原问题分解为重叠子问题，通过 状态定义 和 状态转移方程，避免重复计算，将指数级复杂度降为多项式级。

DP 解题五步曲：

确定状态：分析问题中变化的维度，定义 dp 数组含义（如 dp[i] 表示前 i 个元素的最优解）。
状态转移：找出当前状态与之前状态的依赖关系，写出递推公式。
初始化：设置边界条件，确保递推正确开始。
遍历顺序：确保计算当前状态时所用到的前置状态已经计算完毕。
结果提取：从 dp 数组中获取最终答案（可能是 dp[n]，也可能是 max/min 值）。

LeetCode 热门 100 题中，DP 题占比较大，以下精选 10 道核心题，覆盖 线性DP、背包DP、区间DP、子序列DP 等多种模型，帮助你系统掌握。

1. 爬楼梯（LeetCode 70）

题目：每次可爬 1 或 2 级台阶，求到达第 n 级台阶的不同方法数。

状态定义：dp[i] 表示到达第 i 级台阶的方法数。

状态转移：dp[i] = dp[i-1] + dp[i-2]（要么从 i-1 跨 1 级，要么从 i-2 跨 2 级）。

初始化：dp[0]=1（表示不动），dp[1]=1。

public int climbStairs(int n) {
    if (n <= 1) return 1;
    int[] dp = new int[n + 1];
    dp[0] = 1; dp[1] = 1;
    for (int i = 2; i <= n; i++) {
        dp[i] = dp[i-1] + dp[i-2];
    }
    return dp[n];
}

复杂度：O(n) 时间，O(n) 空间（可优化为 O(1)）。

2. 杨辉三角（LeetCode 118）

题目：生成杨辉三角的前 numRows 行。

状态定义：dp[i][j] 表示第 i 行第 j 个元素（0 索引）。

状态转移：dp[i][j] = dp[i-1][j-1] + dp[i-1][j]，两端为 1。

public List<List<Integer>> generate(int numRows) {
    List<List<Integer>> res = new ArrayList<>();
    for (int i = 0; i < numRows; i++) {
        List<Integer> row = new ArrayList<>();
        for (int j = 0; j <= i; j++) {
            if (j == 0 || j == i) row.add(1);
            else row.add(res.get(i-1).get(j-1) + res.get(i-1).get(j));
        }
        res.add(row);
    }
    return res;
}

复杂度：O(numRows²)，空间 O(numRows²)（输出本身）。

3. 打家劫舍（LeetCode 198）

题目：沿街房屋有非负金额，相邻房屋不能同时偷，求最大盗窃金额。

状态定义：dp[i] 表示前 i 间房屋（0~i-1）能偷到的最大金额。

状态转移：dp[i] = max(dp[i-1], dp[i-2] + nums[i-1])（偷第 i-1 间或不偷）。

初始化：dp[0]=0, dp[1]=nums[0]。

public int rob(int[] nums) {
    if (nums.length == 1) return nums[0];
    int[] dp = new int[nums.length + 1];
    dp[0] = 0; dp[1] = nums[0];
    for (int i = 2; i <= nums.length; i++) {
        dp[i] = Math.max(dp[i-1], dp[i-2] + nums[i-1]);
    }
    return dp[nums.length];
}

复杂度：O(n) 时间，O(1) 可优化。

4. 完全平方数（LeetCode 279）

题目：给定 n，求最少的完全平方数（1,4,9,…）之和等于 n。

状态定义：dp[i] 表示凑成 i 所需的最小平方数个数。

状态转移：dp[i] = min(dp[i - j*j] + 1) 对所有 j² ≤ i。

初始化：dp[0]=0，其余为 INF。

public int numSquares(int n) {
    int[] dp = new int[n + 1];
    Arrays.fill(dp, Integer.MAX_VALUE);
    dp[0] = 0;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j * j <= i; j++) {
            dp[i] = Math.min(dp[i], dp[i - j*j] + 1);
        }
    }
    return dp[n];
}

复杂度：O(n * √n)，空间 O(n)。

5. 零钱兑换（LeetCode 322）

题目：给定不同面额的硬币 coins 和总金额 amount，求凑成总金额所需的最少硬币数（可重复使用）。

状态定义：dp[i] 表示凑成金额 i 所需最少硬币数。

状态转移：dp[i] = min(dp[i - coin] + 1) 对所有 coin ∈ coins。

初始化：dp[0]=0，其余为 INF。

public int coinChange(int[] coins, int amount) {
    int[] dp = new int[amount + 1];
    Arrays.fill(dp, amount + 1);
    dp[0] = 0;
    for (int i = 1; i <= amount; i++) {
        for (int coin : coins) {
            if (i >= coin) dp[i] = Math.min(dp[i], dp[i-coin] + 1);
        }
    }
    return dp[amount] > amount ? -1 : dp[amount];
}

复杂度：O(amount * coins.length)，空间 O(amount)。

6. 单词拆分（LeetCode 139）

题目：给定字符串 s 和字典 wordDict，判断 s 是否可拆分成字典中的单词。

状态定义：dp[i] 表示 s 的前 i 个字符（0~i-1）能否被拆分。

状态转移：dp[i] = true 当存在 j < i，使得 dp[j] = true 且 s[j:i] 在字典中。

初始化：dp[0]=true。

public boolean wordBreak(String s, List<String> wordDict) {
    Set<String> set = new HashSet<>(wordDict);
    boolean[] dp = new boolean[s.length() + 1];
    dp[0] = true;
    for (int i = 1; i <= s.length(); i++) {
        for (int j = 0; j < i; j++) {
            if (dp[j] && set.contains(s.substring(j, i))) {
                dp[i] = true;
                break;
            }
        }
    }
    return dp[s.length()];
}

复杂度：O(n²) 时间，O(n) 空间。

7. 最长递增子序列（LeetCode 300）

题目：给定数组 nums，求最长严格递增子序列的长度。

状态定义：dp[i] 表示以 nums[i] 结尾的最长递增子序列长度。

状态转移：dp[i] = 1 + max(dp[j])，其中 j < i 且 nums[j] < nums[i]。

初始化：dp[i]=1（至少包含自己）。

public int lengthOfLIS(int[] nums) {
    int[] dp = new int[nums.length];
    Arrays.fill(dp, 1);
    int maxLen = 0;
    for (int i = 0; i < nums.length; i++) {
        for (int j = 0; j < i; j++) {
            if (nums[j] < nums[i]) dp[i] = Math.max(dp[i], dp[j] + 1);
        }
        maxLen = Math.max(maxLen, dp[i]);
    }
    return maxLen;
}

复杂度：O(n²) 时间，O(n) 空间（可用二分优化到 O(n log n)）。

8. 乘积最大子数组（LeetCode 152）

题目：给定整数数组 nums，找出乘积最大的连续子数组（至少包含一个数）。

状态定义：维护两个状态，dpMax[i] 表示以 i 结尾的最大乘积，dpMin[i] 表示以 i 结尾的最小乘积（考虑负数）。

状态转移：

dpMax[i] = max(nums[i], nums[i]*dpMax[i-1], nums[i]*dpMin[i-1])
dpMin[i] = min(nums[i], nums[i]*dpMax[i-1], nums[i]*dpMin[i-1])

public int maxProduct(int[] nums) {
    int max = nums[0], min = nums[0], res = nums[0];
    for (int i = 1; i < nums.length; i++) {
        int tempMax = max, tempMin = min;
        max = Math.max(nums[i], Math.max(nums[i] * tempMax, nums[i] * tempMin));
        min = Math.min(nums[i], Math.min(nums[i] * tempMax, nums[i] * tempMin));
        res = Math.max(res, max);
    }
    return res;
}

复杂度：O(n) 时间，O(1) 空间。

9. 分割等和子集（LeetCode 416）

题目：给定非空数组 nums，判断是否可以分成两个和相等的子集。

状态定义：dp[j] 表示是否可以用 nums 中的某些数凑出总和 j。

状态转移：dp[j] = dp[j] || dp[j - num]（01 背包，每个数只能用一次）。

初始化：dp[0]=true。

public boolean canPartition(int[] nums) {
    int sum = Arrays.stream(nums).sum();
    if (sum % 2 != 0) return false;
    int target = sum / 2;
    boolean[] dp = new boolean[target + 1];
    dp[0] = true;
    for (int num : nums) {
        for (int j = target; j >= num; j--) {
            dp[j] = dp[j] || dp[j - num];
        }
    }
    return dp[target];
}

复杂度：O(n * sum/2)，空间 O(sum/2)。

10. 最长有效括号（LeetCode 32）

题目：给定仅包含 ‘(’ 和 ‘)’ 的字符串，求最长有效（格式正确且连续）括号子串的长度。

状态定义：dp[i] 表示以字符 i 结尾的最长有效括号子串长度。

状态转移：

若 s[i] == ‘)’ 且 s[i-1] == ‘(’，则 dp[i] = (i>=2 ? dp[i-2] : 0) + 2
若 s[i] == ‘)’ 且 s[i-1] == ‘)’，且 s[i - dp[i-1] - 1] == ‘(’，则 dp[i] = dp[i-1] + (i-dp[i-1]-2 >=0 ? dp[i-dp[i-1]-2] : 0) + 2

public int longestValidParentheses(String s) {
    int maxLen = 0;
    int[] dp = new int[s.length()];
    for (int i = 1; i < s.length(); i++) {
        if (s.charAt(i) == ')') {
            if (s.charAt(i-1) == '(') {
                dp[i] = (i >= 2 ? dp[i-2] : 0) + 2;
            } else if (i - dp[i-1] > 0 && s.charAt(i - dp[i-1] - 1) == '(') {
                dp[i] = dp[i-1] + (i - dp[i-1] >= 2 ? dp[i - dp[i-1] - 2] : 0) + 2;
            }
            maxLen = Math.max(maxLen, dp[i]);
        }
    }
    return maxLen;
}

复杂度：O(n) 时间，O(n) 空间。

十题对比与分类

题目	DP类型	状态维度	核心转移	空间优化
70. 爬楼梯	线性DP	一维	dp[i] = dp[i-1]+dp[i-2]	O(1)
118. 杨辉三角	二维DP	二维	dp[i][j] = dp[i-1][j-1]+dp[i-1][j]	按需
198. 打家劫舍	线性DP（选/不选）	一维	max(dp[i-1], dp[i-2]+nums[i])	O(1)
279. 完全平方数	完全背包	一维	min(dp[i - j²] + 1)	不可
322. 零钱兑换	完全背包	一维	min(dp[i-coin]+1)	不可
139. 单词拆分	线性DP + 集合	一维	dp[j] && set.contains(s[j:i])	不可
300. 最长递增子序列	子序列DP	一维	max(dp[j]+1) if nums[j]<nums[i]	不可
152. 乘积最大子数组	双状态DP	一维+min	max/min 三种情况	O(1)
416. 分割等和子集	01背包	一维布尔	dp[j] = dp[j]
32. 最长有效括号	区间DP/线性	一维	匹配前一个 ‘)’ 或 ‘(’	不可

共同本质：所有 DP 题都通过 状态定义 和 转移方程 将原问题分解为子问题，并利用子问题的解构建原问题的解。

不同侧重：

线性DP：70、198、139、300、32，状态转移简单，依赖前几个状态。
背包DP：279、322、416，分完全背包和01背包，注意遍历顺序（正序/逆序）。
多维状态：152 需要维护最大和最小两个状态，处理负数。
二维输出：118 直接构造二维表。

总结：动态规划的核心心法

动态规划的本质是"记忆化搜索"，用空间换时间。核心在于找到正确的状态定义和转移方程，这通常需要分析"最后一步"或"子问题"的依赖关系。

DP 解题通用流程：

定义状态：明确 dp 数组每个位置的含义，最好用自然语言描述清楚。

转移方程：根据"最后一步"推导 dp[i] 与之前状态的关系。

初始化和边界：设置 dp[0] 或 dp 的初始值，确保递推正确。

遍历顺序：确保计算 dp[i] 时，所依赖的 dp[j] 已经计算完毕。

返回结果：根据题意，dp[n] 可能是答案，也可能需要遍历 dp 取最值。

堆与贪心辨析 — LeetCode 热门 100 题精讲（Java 向）

Thu, 23 Jul 2026 00:00:00 +0000

堆与贪心的本质区别

在刷题中，堆（Heap）和贪心（Greedy）常被并列提及，但它们的应用场景截然不同：

堆（优先队列）：适用于 维护动态数据集的极值，如求 TopK、中位数、动态排序等。堆本身是一种数据结构，不涉及决策逻辑，只提供高效的插入和获取极值操作。
贪心算法：适用于具有 最优子结构 和 贪心选择性质 的问题，每一步做出当前局部最优选择，最终累积为全局最优。贪心是一种算法思想，需要证明正确性。

LeetCode 热门 100 题中，有四题分别代表了这两类：215. 数组中的第K个最大元素、347. 前K个高频元素、295. 数据流的中位数 属于堆的经典应用；763. 划分字母区间 则是贪心的典型代表。下面逐一剖析。

1. 数组中的第K个最大元素（LeetCode 215）

题目：给定整数数组 nums 和整数 k，返回数组中第 k 个最大的元素。

堆解法：维护一个大小为 k 的小顶堆，堆顶即为第 k 大元素。时间复杂度 O(n log k)，空间 O(k)。

public int findKthLargest(int[] nums, int k) {
    PriorityQueue<Integer> minHeap = new PriorityQueue<>();
    for (int num : nums) {
        minHeap.offer(num);
        if (minHeap.size() > k) minHeap.poll();
    }
    return minHeap.peek();
}

关键点：使用小顶堆存储最大的 k 个数，堆顶是第 k 大。这不是贪心，因为最终结果依赖于全局数据，而非逐步局部决策。

2. 前K个高频元素（LeetCode 347）

题目：给定数组 nums 和整数 k，返回出现频率前 k 高的元素。

堆解法：哈希统计频率，再用大小为 k 的小顶堆按频率筛选。

public int[] topKFrequent(int[] nums, int k) {
    Map<Integer, Integer> freq = new HashMap<>();
    for (int num : nums) freq.put(num, freq.getOrDefault(num, 0) + 1);
    PriorityQueue<int[]> minHeap = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));
    for (Map.Entry<Integer, Integer> e : freq.entrySet()) {
        minHeap.offer(new int[]{e.getValue(), e.getKey()});
        if (minHeap.size() > k) minHeap.poll();
    }
    int[] res = new int[k];
    for (int i = 0; i < k; i++) res[i] = minHeap.poll()[1];
    return res;
}

关键点：同样基于全局统计，与贪心无关。

3. 数据流的中位数（LeetCode 295）

题目：设计数据结构，支持添加整数，并随时获取当前所有元素的中位数。

双堆解法：一个大顶堆存较小的一半，一个小顶堆存较大的一半，保持平衡，中位数为堆顶值。

class MedianFinder {
    private PriorityQueue<Integer> maxHeap; // 存较小的一半
    private PriorityQueue<Integer> minHeap; // 存较大的一半
    public MedianFinder() {
        maxHeap = new PriorityQueue<>(Collections.reverseOrder());
        minHeap = new PriorityQueue<>();
    }
    public void addNum(int num) {
        maxHeap.offer(num);
        minHeap.offer(maxHeap.poll());
        if (minHeap.size() > maxHeap.size()) {
            maxHeap.offer(minHeap.poll());
        }
    }
    public double findMedian() {
        if (maxHeap.size() > minHeap.size()) return maxHeap.peek();
        return (maxHeap.peek() + minHeap.peek()) / 2.0;
    }
}

关键点：中位数依赖于全部数据，堆只是高效维护有序性，并非贪心决策。

4. 划分字母区间（LeetCode 763）

题目：给定字符串 s，将字符串划分为尽可能多的片段，使得每个字母最多出现在一个片段中。返回每个片段的长度。

贪心思路：

先统计每个字符最后出现的位置 lastPos。
遍历字符串，维护当前片段的右边界 right = max(right, lastPos[s[i]])。
当 i == right 时，说明当前片段已经结束，记录长度，并更新左边界。

为什么是贪心？ 每一步我们都尽可能地延长当前片段的右边界，使当前片段包含所有已出现字符的最后位置，直到无法再延伸。这种"能延伸就延伸"的策略，保证了每段尽可能长，从而片段数尽可能多，是局部最优累积到全局最优的典型。

public List<Integer> partitionLabels(String s) {
    int[] last = new int[26];
    for (int i = 0; i < s.length(); i++) last[s.charAt(i) - 'a'] = i;
    List<Integer> res = new ArrayList<>();
    int start = 0, right = 0;
    for (int i = 0; i < s.length(); i++) {
        right = Math.max(right, last[s.charAt(i) - 'a']);
        if (i == right) {
            res.add(i - start + 1);
            start = i + 1;
        }
    }
    return res;
}

复杂度：O(n)，空间 O(1)（固定 26）。

关键点：每一步更新当前片段的最终边界，当到达边界时切割，保证当前片段是满足条件的最短前缀，从而使得后续片段能尽可能多，是贪心选择性质的体现。

四题对比与启发

题目	核心技巧	算法类型	时间复杂度	空间复杂度
215. 第K大元素	小顶堆	堆	O(n log k)	O(k)
347. 前K高频	哈希 + 小顶堆	堆	O(n log k)	O(n)
295. 数据流中位数	双堆	堆	O(log n) 插入	O(n)
763. 划分字母区间	贪心（最后位置）	贪心	O(n)	O(1)

共同本质：前三题都是 数据筛选/排序类 问题，堆提供了高效的极值维护；最后一题是 区间划分类 问题，贪心利用"最后一个位置"的单调性，一次性确定切分点。

总结：何时用堆，何时用贪心？

堆：当问题中出现 “第K大/小”、“前K个”、“中位数”、“动态极值” 等关键词时，优先考虑堆。堆擅长处理流式数据或大规模数据的 TopK 筛选。
贪心：当问题具有 “每一步选择局部最优，不影响后续决策可行性” 的性质时，考虑贪心。常见特征包括区间覆盖、跳跃游戏、活动选择、字符串划分等。

多维动态规划模块 — LeetCode 热门 100 题精讲（Java 向）

Thu, 23 Jul 2026 00:00:00 +0000

多维动态规划概述

一维 DP 已经无法满足复杂的算法问题。当问题涉及 两个维度的变化（如二维网格上的移动、两个字符串的比较）时，我们需要引入多维 DP，通常用二维数组 dp[i][j] 来存储状态。

多维 DP 的常见场景：

网格路径问题：在二维矩阵中从左到右/从上到下移动（62、64）。
双序列匹配问题：比较两个字符串的公共子序列、编辑距离（1143、72）。
区间问题：在字符串内部逐步扩展（5）。

多维 DP 的核心挑战在于 状态维度的设计 和 填表顺序（逐行、逐列、对角线）。

LeetCode 热门 100 题中，有五道经典多维 DP 题：62. 不同路径、64. 最小路径和、5. 最长回文子串、1143. 最长公共子序列、72. 编辑距离。下面逐一拆解。

1. 不同路径（LeetCode 62）

题目：一个机器人位于 m×n 网格的左上角，每次只能向下或向右移动一步，到达右下角共有多少条不同路径？

暴力法：DFS 回溯，O(2^(m+n))，指数爆炸。

二维DP思路：到达 (i, j) 的路径数等于到达 (i-1, j) 和 (i, j-1) 的路径数之和（只能从上方或左方来）。

状态定义：dp[i][j] 表示从起点到达 (i, j) 的路径数。

状态转移：dp[i][j] = dp[i-1][j] + dp[i][j-1]。

初始化：第一行和第一列均为 1（只能直走）。

public int uniquePaths(int m, int n) {
    int[][] dp = new int[m][n];
    for (int i = 0; i < m; i++) dp[i][0] = 1;
    for (int j = 0; j < n; j++) dp[0][j] = 1;
    for (int i = 1; i < m; i++) {
        for (int j = 1; j < n; j++) {
            dp[i][j] = dp[i-1][j] + dp[i][j-1];
        }
    }
    return dp[m-1][n-1];
}

空间优化：只用一维数组滚动更新。

public int uniquePaths(int m, int n) {
    int[] dp = new int[n];
    Arrays.fill(dp, 1);
    for (int i = 1; i < m; i++) {
        for (int j = 1; j < n; j++) {
            dp[j] += dp[j-1];
        }
    }
    return dp[n-1];
}

复杂度：时间 O(m*n)，空间 O(n)（优化后）。

2. 最小路径和（LeetCode 64）

题目：给定 m×n 网格（非负整数），找一条从左上到右下的路径，使路径上的数字总和最小（只能向下或向右移动）。

状态定义：dp[i][j] 表示从起点到达 (i, j) 的最小路径和。

状态转移：dp[i][j] = grid[i][j] + min(dp[i-1][j], dp[i][j-1])。

初始化：dp[0][0] = grid[0][0]；第一行和第一列分别累计。

public int minPathSum(int[][] grid) {
    int m = grid.length, n = grid[0].length;
    int[][] dp = new int[m][n];
    dp[0][0] = grid[0][0];
    for (int i = 1; i < m; i++) dp[i][0] = dp[i-1][0] + grid[i][0];
    for (int j = 1; j < n; j++) dp[0][j] = dp[0][j-1] + grid[0][j];
    for (int i = 1; i < m; i++) {
        for (int j = 1; j < n; j++) {
            dp[i][j] = grid[i][j] + Math.min(dp[i-1][j], dp[i][j-1]);
        }
    }
    return dp[m-1][n-1];
}

空间优化：可复用原网格或一维滚动数组。

public int minPathSum(int[][] grid) {
    int m = grid.length, n = grid[0].length;
    int[] dp = new int[n];
    dp[0] = grid[0][0];
    for (int j = 1; j < n; j++) dp[j] = dp[j-1] + grid[0][j];
    for (int i = 1; i < m; i++) {
        dp[0] += grid[i][0];
        for (int j = 1; j < n; j++) {
            dp[j] = grid[i][j] + Math.min(dp[j], dp[j-1]);
        }
    }
    return dp[n-1];
}

复杂度：时间 O(m*n)，空间 O(n)。

关键点：注意初始化边界值，递推时取上方和左方的最小值。

3. 最长回文子串（LeetCode 5）

题目：给定字符串 s，找出其中最长的回文子串。

二维DP思路：区间 DP，用 dp[i][j] 表示子串 s[i..j] 是否为回文。

状态定义：dp[i][j] = true 当且仅当 s[i] == s[j] 且 (j-i < 2 或 dp[i+1][j-1] == true)。

状态转移：长度从 1 到 n 递增，确保子问题已计算。

public String longestPalindrome(String s) {
    int n = s.length();
    if (n < 2) return s;
    boolean[][] dp = new boolean[n][n];
    int start = 0, maxLen = 1;
    for (int i = 0; i < n; i++) dp[i][i] = true;
    for (int len = 2; len <= n; len++) {
        for (int i = 0; i + len - 1 < n; i++) {
            int j = i + len - 1;
            if (s.charAt(i) == s.charAt(j)) {
                if (len == 2 || dp[i+1][j-1]) {
                    dp[i][j] = true;
                    if (len > maxLen) {
                        maxLen = len;
                        start = i;
                    }
                }
            }
        }
    }
    return s.substring(start, start + maxLen);
}

复杂度：时间 O(n²)，空间 O(n²)。

关键点：DP 填表顺序依赖区间长度；也可以使用中心扩展（空间 O(1)），但 DP 解法是多维区间 DP 的典型代表。

4. 最长公共子序列（LeetCode 1143）

题目：给定两个字符串 text1 和 text2，返回它们的最长公共子序列的长度（不要求连续）。

状态定义：dp[i][j] 表示 text1 的前 i 个字符和 text2 的前 j 个字符的 LCS 长度。

状态转移：

若 text1[i-1] == text2[j-1]：dp[i][j] = dp[i-1][j-1] + 1
否则：dp[i][j] = max(dp[i-1][j], dp[i][j-1])

public int longestCommonSubsequence(String text1, String text2) {
    int m = text1.length(), n = text2.length();
    int[][] dp = new int[m+1][n+1];
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            if (text1.charAt(i-1) == text2.charAt(j-1)) {
                dp[i][j] = dp[i-1][j-1] + 1;
            } else {
                dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);
            }
        }
    }
    return dp[m][n];
}

空间优化：滚动数组（只用两行或一行）。

public int longestCommonSubsequence(String text1, String text2) {
    int m = text1.length(), n = text2.length();
    int[] dp = new int[n+1];
    for (int i = 1; i <= m; i++) {
        int prev = 0;
        for (int j = 1; j <= n; j++) {
            int temp = dp[j];
            if (text1.charAt(i-1) == text2.charAt(j-1)) {
                dp[j] = prev + 1;
            } else {
                dp[j] = Math.max(dp[j], dp[j-1]);
            }
            prev = temp;
        }
    }
    return dp[n];
}

复杂度：时间 O(m*n)，空间 O(n)。

关键点：注意 dp 中 prev 保存的是左上角的值（即上一轮的 dp[j-1]），避免被覆盖。

5. 编辑距离（LeetCode 72）

题目：给定两个单词 word1 和 word2，计算将 word1 转换成 word2 所需的最少操作数（插入、删除、替换）。

状态定义：dp[i][j] 表示将 word1 的前 i 个字符转换成 word2 的前 j 个字符所需的最少操作数。

状态转移：

若 word1[i-1] == word2[j-1]：dp[i][j] = dp[i-1][j-1]
否则：dp[i][j] = 1 + min(dp[i-1][j]（删除）, dp[i][j-1]（插入）, dp[i-1][j-1]（替换）)

初始化：dp[i][0] = i（删除所有字符），dp[0][j] = j（插入所有字符）。

public int minDistance(String word1, String word2) {
    int m = word1.length(), n = word2.length();
    int[][] dp = new int[m+1][n+1];
    for (int i = 0; i <= m; i++) dp[i][0] = i;
    for (int j = 0; j <= n; j++) dp[0][j] = j;
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            if (word1.charAt(i-1) == word2.charAt(j-1)) {
                dp[i][j] = dp[i-1][j-1];
            } else {
                dp[i][j] = 1 + Math.min(dp[i-1][j], Math.min(dp[i][j-1], dp[i-1][j-1]));
            }
        }
    }
    return dp[m][n];
}

空间优化：滚动数组（一维）。

public int minDistance(String word1, String word2) {
    int m = word1.length(), n = word2.length();
    int[] dp = new int[n+1];
    for (int j = 0; j <= n; j++) dp[j] = j;
    for (int i = 1; i <= m; i++) {
        int prev = dp[0];
        dp[0] = i;
        for (int j = 1; j <= n; j++) {
            int temp = dp[j];
            if (word1.charAt(i-1) == word2.charAt(j-1)) {
                dp[j] = prev;
            } else {
                dp[j] = 1 + Math.min(dp[j], Math.min(dp[j-1], prev));
            }
            prev = temp;
        }
    }
    return dp[n];
}

复杂度：时间 O(m*n)，空间 O(n)。

关键点：编辑距离是最全面的双序列 DP 模型，涵盖了增删改三种操作，理解它对后续其他字符串 DP 题有极大帮助。

五题对比与分类

题目	类型	维度含义	转移方向	空间优化难度
62. 不同路径	网格路径	(行, 列)	上方+左方	易（一维）
64. 最小路径和	网格带权路径	(行, 列)	上方/左方取min	易（一维）
5. 最长回文子串	区间DP	(左边界, 右边界)	由内向外扩展	难（依赖对角线）
1143. 最长公共子序列	双序列匹配	(第一个串位置, 第二个串位置)	匹配/不匹配两种分支	中（滚动数组需保留左上角）
72. 编辑距离	双序列带操作	(第一个串位置, 第二个串位置)	三种操作取min	中（同上）

共同本质：二维 DP 的核心都是 构建二维表格，根据相邻状态递推。网格题依赖左上+上方+左方；区间题依赖内部小区间；双序列题依赖左上、上、左。

不同侧重：

网格题（62、64）：填表顺序固定（从左到右，从上到下）。
区间题（5）：填表顺序按长度递增。
双序列题（1143、72）：填表顺序按字符串位置递增（行/列）。

总结：多维DP的核心心法

多维DP是解决多因素决策问题的利器，核心是定义清晰的状态维度和转移规则。填表顺序决定了子问题是否提前就绪，空间优化常常可以用滚动数组降至一维。

应用多维DP的通用步骤：

分析变量个数：问题中有几个独立变化的因素（如两个字符串的位置、矩阵的行列、区间左右端点）。

定义dp数组：根据变量个数选择维度，明确每个维度的含义。

推导转移方程：找到当前状态与"前一步"或"子区间"的关系，尤其注意边界条件。

确定填表顺序：

矩阵路径：按行或按列。

区间DP：按区间长度递增。

双序列：按字符串位置递增。

空间优化：如果当前状态只依赖于上一行/上一列，可用滚动数组降低空间复杂度。

堆模块 — LeetCode 热门 100 题精讲（Java 向）

Wed, 22 Jul 2026 00:00:00 +0000

堆的核心概念

堆（Heap）是一种特殊的完全二叉树结构，通常用数组实现。Java 中的 PriorityQueue 默认是小顶堆（堆顶元素最小），通过传入 Comparator.reverseOrder() 可变为大顶堆。

堆的核心操作时间复杂度：

插入（offer / add）：O(log n)
删除堆顶（poll）：O(log n)
获取堆顶（peek）：O(1)

堆在算法题中的核心价值在于 动态维护一组元素中的极值，特别适合 TopK 问题（求第 K 大/小、前 K 个高频元素等）。当数据量极大且无法全量排序时，堆能以 O(n log K) 的复杂度完成筛选，远优于全排序的 O(n log n)。

LeetCode 热门 100 题中，有三道题与堆密切相关：215. 数组中的第K个最大元素（堆求 TopK）、347. 前 K 个高频元素（哈希表统计 + 堆筛选）、395. 至少有K个重复字符的最长子串（堆作为辅助工具，配合分治解决）。前两题是堆的经典应用，第三题展示了堆在复杂场景中的灵活运用。

1. 数组中的第K个最大元素（LeetCode 215）

题目：给定整数数组 nums 和整数 k，返回数组中第 k 个最大的元素。注意是排序后的第 k 个最大元素，而非第 k 个不同元素。

暴力法：对数组排序后取第 n - k 个元素，时间复杂度 O(n log n)。

堆优化思路：维护一个大小为 k 的小顶堆。遍历数组，将元素加入堆中，当堆大小超过 k 时弹出堆顶（最小的元素）。遍历结束后，堆顶就是第 k 大的元素。因为堆中保留的是当前遍历过的所有元素中 最大的 k 个，堆顶是这 k 个中最小的，即全局第 k 大。

具体步骤：

创建一个小顶堆 PriorityQueue<Integer> minHeap = new PriorityQueue<>()。
遍历数组每个元素 num：
- minHeap.offer(num)。
- 如果 minHeap.size() > k，执行 minHeap.poll()。
返回 minHeap.peek()。

public int findKthLargest(int[] nums, int k) {
    PriorityQueue<Integer> minHeap = new PriorityQueue<>();
    for (int num : nums) {
        minHeap.offer(num);
        if (minHeap.size() > k) {
            minHeap.poll();
        }
    }
    return minHeap.peek();
}

复杂度：时间复杂度 O(n log k)，空间复杂度 O(k)。

关键点：使用小顶堆而非大顶堆，因为我们要保留最大的 k 个数，堆顶是这 k 个数中最小的，便于淘汰。当 k 接近 n 时，堆方案不如直接排序，但 k 较小时优势明显。

2. 前K个高频元素（LeetCode 347）

题目：给定整数数组 nums 和整数 k，返回出现频率前 k 高的元素。可以按任意顺序返回答案。

暴力法：统计每个元素的频率，然后按频率排序取前 k 个，时间复杂度 O(n log n)。

堆优化思路：先用哈希表统计每个元素的频率，然后用大小为 k 的小顶堆存储 (频率, 元素) 对。遍历哈希表，将键值对加入堆中，当堆大小超过 k 时弹出频率最小的元素。遍历结束后，堆中剩下的就是频率最高的 k 个元素。

具体步骤：

用 HashMap<Integer, Integer> 统计每个元素的出现次数。
创建小顶堆 PriorityQueue<int[]> minHeap = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]))，存储 [频率, 元素]。
遍历哈希表的 entrySet：
- minHeap.offer(new int[]{freq, val})。
- 如果 minHeap.size() > k，执行 minHeap.poll()。
从堆中取出所有元素，返回结果数组。

public int[] topKFrequent(int[] nums, int k) {
    Map<Integer, Integer> freqMap = new HashMap<>();
    for (int num : nums) {
        freqMap.put(num, freqMap.getOrDefault(num, 0) + 1);
    }
    PriorityQueue<int[]> minHeap = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));
    for (Map.Entry<Integer, Integer> entry : freqMap.entrySet()) {
        minHeap.offer(new int[]{entry.getValue(), entry.getKey()});
        if (minHeap.size() > k) {
            minHeap.poll();
        }
    }
    int[] result = new int[k];
    for (int i = 0; i < k; i++) {
        result[i] = minHeap.poll()[1];
    }
    return result;
}

复杂度：时间复杂度 O(n log k)，空间复杂度 O(n)。

关键点：堆中存储的是 [频率, 元素]，比较器按频率排序。这里 k 是频率最高的前 k 个元素，与第 215 题的 k 含义一致，都是"保留最大的 k 个"。

3. 至少有K个重复字符的最长子串（LeetCode 395）

题目：给定字符串 s 和整数 k，找出 s 中的最长子串，要求该子串中 每个字符 的出现次数都不少于 k。返回该子串的长度。

暴力法：枚举所有子串，统计每个字符频次并检查是否都 >= k，时间复杂度 O(n³) 或 O(n²)。

堆辅助的分治思路：这题最经典的解法是分治，但堆可以作为一个辅助工具来优化某些步骤。

核心观察：如果某个字符 c 在整个字符串中的总出现次数小于 k，那么任何包含 c 的子串都不可能满足条件。因此，可以 以 c 为分割点 将字符串切分成若干段，递归处理每一段。

堆的辅助作用：在分治过程中，需要快速找出当前段中所有出现次数 < k 的字符作为分割点。可以用一个最小堆存储 (出现次数, 字符)，堆顶就是出现次数最少的字符，如果堆顶次数 >= k，则当前段已经满足条件，直接返回段长；否则弹出该字符作为分割点进行递归。

具体步骤：

统计当前段 [left, right] 内每个字符的出现次数。
将出现次数 < k 的字符放入小顶堆（按次数排序）。
如果堆为空，说明当前段所有字符出现次数都 >= k，返回段长 right - left + 1。
否则，取出堆顶字符 splitChar，以该字符为分割点，将段分成若干子段，递归处理每个子段，取最大值。

public int longestSubstring(String s, int k) {
    return dfs(s, 0, s.length() - 1, k);
}

private int dfs(String s, int left, int right, int k) {
    if (left > right) return 0;
    // 统计当前段频次
    int[] freq = new int[26];
    for (int i = left; i <= right; i++) {
        freq[s.charAt(i) - 'a']++;
    }
    // 小顶堆存储出现次数 < k 的字符
    PriorityQueue<int[]> minHeap = new PriorityQueue<>(Comparator.comparingInt(a -> a[1]));
    for (int i = 0; i < 26; i++) {
        if (freq[i] > 0 && freq[i] < k) {
            minHeap.offer(new int[]{i, freq[i]});
        }
    }
    if (minHeap.isEmpty()) {
        return right - left + 1;
    }
    int splitChar = minHeap.poll()[0];
    int maxLen = 0;
    int start = left;
    for (int i = left; i <= right; i++) {
        if (s.charAt(i) - 'a' == splitChar) {
            maxLen = Math.max(maxLen, dfs(s, start, i - 1, k));
            start = i + 1;
        }
    }
    maxLen = Math.max(maxLen, dfs(s, start, right, k));
    return maxLen;
}

复杂度：最坏情况下 O(n²)（如每次只分割一个字符），平均情况优于暴力。堆的引入使得寻找分割字符更高效（O(26 log 26) 常数级），但整体复杂度仍由递归决定。

关键点：这题的堆用法与传统 TopK 不同——堆在这里是 辅助筛选工具，用于快速定位"不合格"的字符作为分割点。如果不用堆，每次遍历 26 个字母也能达到同样效果（因为字符集只有 26 个），但堆的思路更具通用性，当字符集更大时优势更明显。

三题对比与启发

题目	堆的作用	堆类型	时间复杂度	核心逻辑
第K大元素	保留最大的 k 个	小顶堆	O(n log k)	堆顶是第 k 大
前K高频元素	保留频次最高的 k 个	小顶堆	O(n log k)	哈希统计 + 堆筛选
重复字符最长子串	辅助寻找分割点	小顶堆	O(n²) 最坏	分治 + 堆定位"坏字符"

共同本质：堆在这三题中的核心价值都是 快速获取当前数据集中的极值（最小值或频率最低值）。无论是保留 TopK 时的"淘汰最小值"，还是分治时的"找到最少出现的字符"，堆都提供了 O(log n) 的极值访问能力。

不同侧重：

第 215 题：堆作为 唯一数据结构，完成 TopK 筛选。
第 347 题：堆与哈希表配合，先统计再筛选。
第 395 题：堆作为 辅助工具，嵌入分治框架中加速决策。

总结：堆模块的核心心法

堆的本质是"动态极值容器"。当问题涉及"保留最大的 K 个"、“淘汰最小的”、“反复取当前最值"等场景时，堆往往是 O(n log K) 最优解的不二之选。

应用堆的通用思考路径：

识别问题是否需要 维护一组数据的极值。

确定堆中存储的元素类型（数值、频率、配对对象等）。

确定堆的类型——小顶堆用于保留最大的 K 个（淘汰最小的），大顶堆用于保留最小的 K 个（淘汰最大的）。

注意堆的大小控制：通常保持堆大小不超过 K，每次插入后检查并弹出。

技巧模块 — LeetCode 热门 100 题精讲（Java 向）

Wed, 22 Jul 2026 00:00:00 +0000

技巧模块概述

算法题中有一类题目，不依赖传统的 DP、二分或贪心框架，而是需要巧妙的 数学性质 或 指针操作 来达到最优解。这类题目考验的是对数据结构和特定规律的洞察力，一旦掌握技巧，代码往往非常简洁且高效。

本章精选的五道题分别代表了五种不同的算法技巧：

136. 只出现一次的数字：异或运算的交换律与结合律。
169. 多数元素：Boyer-Moore 投票算法（正负抵消）。
75. 颜色分类：荷兰国旗问题（三指针原地分区）。
31. 下一个排列：字典序排列的生成规律（双指针反转）。
287. 寻找重复数：链表判环（Floyd 判圈算法）在数组上的应用。

1. 只出现一次的数字（LeetCode 136）

题目：给定一个非空整数数组，其中某个元素只出现一次，其余每个元素均出现两次。找出那个只出现一次的元素。要求 O(n) 时间，O(1) 空间。

常规思路：哈希表统计频次，但需要 O(n) 空间。

技巧解法（异或）：利用异或运算的三大性质：

交换律：a ^ b ^ c = a ^ c ^ b
任何数与 0 异或等于本身：0 ^ a = a
任何数与自己异或等于 0：a ^ a = 0

将所有数字进行异或运算，成对出现的数字会抵消为 0，最终剩下的就是只出现一次的数字。

public int singleNumber(int[] nums) {
    int res = 0;
    for (int num : nums) {
        res ^= num;
    }
    return res;
}

复杂度：时间 O(n)，空间 O(1)。

关键点：异或运算是处理"成对出现"问题的杀手锏，不仅限于数字，也可扩展到字符（如找出现奇数次的字符）。

2. 多数元素（LeetCode 169）

题目：给定大小为 n 的数组，找出其中出现次数大于 ⌊n/2⌋ 的元素。要求 O(n) 时间，O(1) 空间。

常规思路：排序后取中位数（O(n log n)），或哈希统计（O(n) 空间）。

技巧解法（Boyer-Moore 投票算法）：核心思想是"正负抵消"。维护一个候选众数 candidate 和一个计数器 count。遍历数组：

若 count == 0，将当前元素设为候选。
若当前元素等于 candidate，count++，否则 count--。由于众数数量超过一半，它最终会抵消掉所有非众数并留下来。

public int majorityElement(int[] nums) {
    int candidate = 0, count = 0;
    for (int num : nums) {
        if (count == 0) candidate = num;
        count += (num == candidate) ? 1 : -1;
    }
    return candidate;
}

复杂度：时间 O(n)，空间 O(1)。

关键点：抵消过程不关心具体抵消了谁，只关心票数差额。该算法只保证众数存在时正确（题目已保证）。

3. 颜色分类（LeetCode 75）

题目：给定包含 0、1、2 的数组，原地排序，使所有 0 在前，1 居中，2 在后。不能使用库函数排序。

常规思路：计数排序（两趟遍历），或快排。

技巧解法（荷兰国旗问题 / 三指针）：维护三个指针：

p0：指向下一个 0 应该放的位置（从左起）。
p2：指向下一个 2 应该放的位置（从右起）。
i：当前遍历指针。

遍历时：

若 nums[i] == 0，交换 i 和 p0，i++，p0++。
若 nums[i] == 2，交换 i 和 p2，p2--（注意 i 不前进，因为换来的新值还需检查）。
若 nums[i] == 1，i++。

public void sortColors(int[] nums) {
    int p0 = 0, p2 = nums.length - 1;
    int i = 0;
    while (i <= p2) {
        if (nums[i] == 0) {
            swap(nums, i, p0);
            i++;
            p0++;
        } else if (nums[i] == 2) {
            swap(nums, i, p2);
            p2--;
        } else {
            i++;
        }
    }
}
private void swap(int[] nums, int i, int j) {
    int tmp = nums[i];
    nums[i] = nums[j];
    nums[j] = tmp;
}

复杂度：时间 O(n)，空间 O(1)。

关键点：遇到 2 时 i 不前进，因为从 p2 换过来的元素可能是 0 或 1，需要下一轮继续处理。

4. 下一个排列（LeetCode 31）

题目：给定整数数组，找出其按字典序排列的下一个更大的排列。若不存在（已是降序），则将其升序排列（最小的排列）。要求原地修改。

技巧解法（字典序规律）：

从右向左找第一个升序对 (i, i+1)，满足 nums[i] < nums[i+1]。此时 i 右侧是降序序列。
再从右向左找第一个大于 nums[i] 的元素 nums[j]。
交换 nums[i] 和 nums[j]。
将 i+1 到末尾的序列反转（因为原本是降序，反转后变成升序，得到最小后缀）。

public void nextPermutation(int[] nums) {
    int i = nums.length - 2;
    while (i >= 0 && nums[i] >= nums[i+1]) i--;
    if (i >= 0) {
        int j = nums.length - 1;
        while (j >= 0 && nums[j] <= nums[i]) j--;
        swap(nums, i, j);
    }
    reverse(nums, i + 1, nums.length - 1);
}
private void reverse(int[] nums, int l, int r) {
    while (l < r) swap(nums, l++, r--);
}

复杂度：时间 O(n)，空间 O(1)。

关键点：找到第一个升序对是关键，它决定了可变动的最高位。若完全降序，直接反转整个数组。

5. 寻找重复数（LeetCode 287）

题目：给定包含 n+1 个整数的数组，数字都在 1~n 之间，只有一个数字重复出现（可能多次），找出这个重复数。要求不修改数组，且只用 O(1) 额外空间。

常规思路：二分答案（O(n log n)），或快慢指针。

技巧解法（Floyd 判圈算法）：将数组视为一个链表，其中 i -> nums[i] 表示节点 i 指向节点 nums[i]。因为存在重复数，所以这个链表中必然存在环。我们使用快慢指针找到环的入口，入口节点就是重复的数字。

public int findDuplicate(int[] nums) {
    int slow = nums[0];
    int fast = nums[0];
    // 第一阶段：找到相遇点
    do {
        slow = nums[slow];
        fast = nums[nums[fast]];
    } while (slow != fast);
    // 第二阶段：从头开始，以相同速度走到入口
    slow = nums[0];
    while (slow != fast) {
        slow = nums[slow];
        fast = nums[fast];
    }
    return slow;
}

复杂度：时间 O(n)，空间 O(1)。

关键点：满足 nums[i] 的范围在 1~n 且数组长度 n+1，才能保证将 i 映射到 nums[i] 不会越界（且 0 不会出现在值中，所以从 0 出发一定成环）。入口点就是被两个不同下标指向的值，即重复的数。

五题对比与总结

题目	核心技巧	数据结构/操作	时间复杂度	空间复杂度
136. 只出现一次的数字	异或消去	位运算	O(n)	O(1)
169. 多数元素	摩尔投票（正负抵消）	计数器	O(n)	O(1)
75. 颜色分类	荷兰国旗（三指针）	原地交换	O(n)	O(1)
31. 下一个排列	字典序规律 + 反转	双指针	O(n)	O(1)
287. 寻找重复数	Floyd 判圈（快慢指针）	数组映射链表	O(n)	O(1)

共同本质：这些技巧题都摆脱了常规的"遍历存储"或"排序"思路，而是深入挖掘问题内在的 数学性质（异或、众数票数）、数据结构关联（数组视为链表）或 排列规则（字典序），从而实现最优的时间和空间复杂度。

应试指南：

看到"成对出现找唯一"，想到异或。
看到"出现次数超过一半"，想到摩尔投票。
看到"三类元素原地排序"，想到荷兰国旗。
看到"字典序下一个"，记住"升序对 + 交换 + 反转"三步走。
看到"n+1 个数在 1~n 之间找重复"，且不能改数组，想到 Floyd 判圈。

栈模块 — LeetCode 热门 100 题精讲（Java 向）

Wed, 22 Jul 2026 00:00:00 +0000

栈思想概述

栈（Stack）是一种后进先出（LIFO）的数据结构，其核心操作是入栈（push）、出栈（pop）和查看栈顶（peek）。在算法题中，栈的应用场景可归结为三类：

匹配与校验：利用栈的"抵消"特性，如括号匹配、字符串消消乐。
状态保存与回溯：保存历史上下文，如最小栈、字符串解码中的多层嵌套。
单调栈：维护栈内元素单调递增或递减，快速求解"下一个更大/更小元素"或"柱状图最大矩形"等问题。

LeetCode 热门 100 题中有五道栈经典题：20. 有效的括号（匹配校验）、155. 最小栈（状态保存）、394. 字符串解码（嵌套回溯）、739. 每日温度（单调栈基础）、84. 柱状图中最大的矩形（单调栈进阶）。下面逐一拆解。

1. 有效的括号（LeetCode 20）

题目：给定只包含 '(', ')', '{', '}', '[', ']' 的字符串，判断括号是否有效（左括号必须用相同类型右括号闭合，且正确嵌套）。

核心思路：遇到左括号入栈，遇到右括号则弹出栈顶并检查是否匹配。若最后栈为空则有效。

public boolean isValid(String s) {
    Deque<Character> stack = new ArrayDeque<>();
    Map<Character, Character> map = Map.of(')', '(', '}', '{', ']', '[');
    for (char c : s.toCharArray()) {
        if (map.containsKey(c)) {
            if (stack.isEmpty() || stack.pop() != map.get(c)) return false;
        } else {
            stack.push(c);
        }
    }
    return stack.isEmpty();
}

复杂度：时间 O(n)，空间 O(n)。

关键点：用 Deque 代替 Stack（Java 官方推荐）；右括号出现时栈顶必须匹配；最后检查栈是否为空，防止多出左括号。

2. 最小栈（LeetCode 155）

题目：设计一个支持 push、pop、top 和在常数时间内检索最小元素的栈（getMin）。

核心思路：维护两个栈，一个普通栈存所有元素，另一个单调栈存当前最小值（每次入栈时，若新元素小于等于当前最小值则同步入最小栈；出栈时若出栈元素等于最小栈顶则同步出栈）。

class MinStack {
    private Deque<Integer> stack;
    private Deque<Integer> minStack;
    public MinStack() {
        stack = new ArrayDeque<>();
        minStack = new ArrayDeque<>();
    }
    public void push(int val) {
        stack.push(val);
        if (minStack.isEmpty() || val <= minStack.peek()) {
            minStack.push(val);
        }
    }
    public void pop() {
        if (stack.pop().equals(minStack.peek())) {
            minStack.pop();
        }
    }
    public int top() { return stack.peek(); }
    public int getMin() { return minStack.peek(); }
}

复杂度：所有操作 O(1)，空间 O(n)。

关键点：入栈时用 <= 而非 <，避免重复最小值丢失；出栈比较要用 equals。

3. 字符串解码（LeetCode 394）

题目：给定编码字符串 k[encoded_string]，表示 encoded_string 重复 k 次，解码展开。如 3[a2[c]] → accaccacc。

核心思路：使用两个栈，一个存数字（重复次数），一个存当前构建的字符串前缀。

public String decodeString(String s) {
    Deque<Integer> countStack = new ArrayDeque<>();
    Deque<StringBuilder> strStack = new ArrayDeque<>();
    StringBuilder current = new StringBuilder();
    int k = 0;
    for (char c : s.toCharArray()) {
        if (Character.isDigit(c)) {
            k = k * 10 + (c - '0');
        } else if (c == '[') {
            countStack.push(k);
            strStack.push(current);
            current = new StringBuilder();
            k = 0;
        } else if (c == ']') {
            int repeat = countStack.pop();
            StringBuilder prev = strStack.pop();
            while (repeat-- > 0) prev.append(current);
            current = prev;
        } else {
            current.append(c);
        }
    }
    return current.toString();
}

复杂度：时间 O(n * maxK)，空间 O(n)。

关键点：数字可能有多位，需要连续累加；遇到 [ 时保存当前状态，重置后处理嵌套。

4. 每日温度（LeetCode 739）

题目：给定每日温度数组，返回数组 answer[i]，表示第 i 天需要等待多少天才能遇到更高温度；如果之后没有更高温度则填入 0。

核心思路：维护一个单调递减栈（栈底到栈顶温度递减）。从左向右遍历，当当前温度大于栈顶对应温度时，弹出栈顶并记录差值；否则入栈。

public int[] dailyTemperatures(int[] temperatures) {
    int n = temperatures.length;
    int[] ans = new int[n];
    Deque<Integer> stack = new ArrayDeque<>();
    for (int i = 0; i < n; i++) {
        while (!stack.isEmpty() && temperatures[i] > temperatures[stack.peek()]) {
            int idx = stack.pop();
            ans[idx] = i - idx;
        }
        stack.push(i);
    }
    return ans;
}

复杂度：时间 O(n)，空间 O(n)。

关键点：栈内存的是下标；while 循环确保当前温度大于栈顶温度时，栈顶元素的下一个更高温度就是当前 i。

5. 柱状图中最大的矩形（LeetCode 84）

题目：给定非负整数数组 heights，求柱状图中能勾勒出的最大矩形面积。

核心思路：单调递增栈（找左右两侧第一个比当前柱子矮的位置）。遍历时，当 heights[i] < heights[stack.peek()] 时，弹出栈顶，并以该弹出柱子为矩形高度，右边界为 i，左边界为新的栈顶，计算面积。为了统一处理，在数组首尾添加高度为 0 的哨兵。

public int largestRectangleArea(int[] heights) {
    int n = heights.length;
    int[] newHeights = new int[n + 2];
    System.arraycopy(heights, 0, newHeights, 1, n);
    Deque<Integer> stack = new ArrayDeque<>();
    int maxArea = 0;
    for (int i = 0; i < newHeights.length; i++) {
        while (!stack.isEmpty() && newHeights[i] < newHeights[stack.peek()]) {
            int height = newHeights[stack.pop()];
            int width = i - stack.peek() - 1;
            maxArea = Math.max(maxArea, height * width);
        }
        stack.push(i);
    }
    return maxArea;
}

复杂度：时间 O(n)，空间 O(n)。

关键点：哨兵（首尾 0）避免了处理空栈和边界判断；当遇到更矮柱子时，说明栈顶柱子的右边界确定，左边界为弹出后的新栈顶；计算宽度为 right - left - 1。

五题对比与总结

题目	栈类型	核心操作	时间复杂度	空间复杂度	关键难点
有效的括号	基础匹配	入栈/出栈匹配	O(n)	O(n)	左右括号映射
最小栈	状态保存	双栈同步	O(1)	O(n)	最小值栈同步逻辑
字符串解码	嵌套回溯	双栈 + 字符串拼接	O(n * maxK)	O(n)	数字累加与嵌套恢复
每日温度	单调栈	维护递减栈	O(n)	O(n)	下标记录与差值计算
柱状图最大矩形	单调栈（进阶）	维护递增栈 + 哨兵	O(n)	O(n)	左右边界确定与面积公式

共同本质：栈的核心价值在于 “保存等待处理的状态”。括号匹配等待右括号来抵消；最小栈等待元素出栈时同步更新最小值；字符串解码等待 ] 来触发重复；单调栈等待一个破坏单调性的元素来触发面积/温度计算。

总结心法：

需要 成对抵消 或匹配 → 基础栈。
需要 保存当前环境状态 供后续回溯 → 多栈配合。
需要求 下一个更大/更小元素 → 单调栈（存下标）。
需要求 连续区间最值或面积 → 单调栈 + 左右边界计算（通常用哨兵简化）。

二叉树模块 — LeetCode 热门 100 题精讲（Java 向）

Tue, 21 Jul 2026 00:00:00 +0000

二叉树问题概述

二叉树是算法面试的绝对核心模块，它天然契合递归思维，几乎每道题都可以用递归或迭代实现。二叉树的解题技巧可归纳为三类：

遍历框架：前序、中序、后序（DFS）和层序（BFS），是所有题目的基础。
递归分解：将问题拆分为左子树、右子树和根节点的处理，如最大深度、翻转、对称、路径和等。
回溯与路径：利用 DFS 遍历所有根到叶子的路径，处理路径和、最近公共祖先等。

LeetCode 热门 100 题中共有 15 道二叉树题，覆盖了上述所有场景。下面按技巧分类展开。

一、基础遍历与性质（94、104、226、101）

94. 二叉树的中序遍历

题目：返回二叉树的中序遍历（左-根-右）。

核心思路：递归或迭代（栈）。递归最简洁，迭代则模拟栈过程。

public List<Integer> inorderTraversal(TreeNode root) {
    List<Integer> res = new ArrayList<>();
    inorder(root, res);
    return res;
}
private void inorder(TreeNode node, List<Integer> res) {
    if (node == null) return;
    inorder(node.left, res);
    res.add(node.val);
    inorder(node.right, res);
}

复杂度：时间 O(n)，空间 O(h)（递归栈）。

104. 二叉树的最大深度

题目：返回二叉树的最大深度（根节点到最远叶子节点数）。

核心思路：递归，maxDepth(root) = 1 + max(maxDepth(left), maxDepth(right))。

public int maxDepth(TreeNode root) {
    if (root == null) return 0;
    return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
}

复杂度：时间 O(n)，空间 O(h)。

226. 翻转二叉树

题目：将二叉树左右子树交换。

核心思路：递归，先翻转左右子树，再交换当前节点的左右指针。

public TreeNode invertTree(TreeNode root) {
    if (root == null) return null;
    TreeNode left = invertTree(root.left);
    TreeNode right = invertTree(root.right);
    root.left = right;
    root.right = left;
    return root;
}

复杂度：时间 O(n)，空间 O(h)。

101. 对称二叉树

题目：判断二叉树是否镜像对称。

核心思路：递归比较左右子树是否互为镜像。定义辅助函数 isMirror(t1, t2)，检查 t1.val == t2.val 且 isMirror(t1.left, t2.right) 且 isMirror(t1.right, t2.left)。

public boolean isSymmetric(TreeNode root) {
    return isMirror(root, root);
}
private boolean isMirror(TreeNode t1, TreeNode t2) {
    if (t1 == null && t2 == null) return true;
    if (t1 == null || t2 == null) return false;
    return t1.val == t2.val && isMirror(t1.left, t2.right) && isMirror(t1.right, t2.left);
}

复杂度：时间 O(n)，空间 O(h)。

二、层序与构造（102、108）

102. 二叉树的层序遍历

题目：按层返回节点值（每层一个列表）。

核心思路：BFS 使用队列，记录每层的节点数，逐层收集。

public List<List<Integer>> levelOrder(TreeNode root) {
    List<List<Integer>> res = new ArrayList<>();
    if (root == null) return res;
    Queue<TreeNode> q = new LinkedList<>();
    q.offer(root);
    while (!q.isEmpty()) {
        int size = q.size();
        List<Integer> level = new ArrayList<>();
        for (int i = 0; i < size; i++) {
            TreeNode node = q.poll();
            level.add(node.val);
            if (node.left != null) q.offer(node.left);
            if (node.right != null) q.offer(node.right);
        }
        res.add(level);
    }
    return res;
}

复杂度：时间 O(n)，空间 O(n)。

108. 将有序数组转换为二叉搜索树

题目：将升序数组转换为高度平衡的二叉搜索树（BST）。

核心思路：每次取中间元素作为根，递归构造左右子树。

public TreeNode sortedArrayToBST(int[] nums) {
    return build(nums, 0, nums.length - 1);
}
private TreeNode build(int[] nums, int left, int right) {
    if (left > right) return null;
    int mid = left + (right - left) / 2;
    TreeNode root = new TreeNode(nums[mid]);
    root.left = build(nums, left, mid - 1);
    root.right = build(nums, mid + 1, right);
    return root;
}

复杂度：时间 O(n)，空间 O(log n)（递归栈）。

三、BST 性质（98、230）

98. 验证二叉搜索树

题目：判断二叉树是否满足 BST 性质（左 < 根 < 右）。

核心思路：中序遍历应为升序，或递归传递上下界。

public boolean isValidBST(TreeNode root) {
    return validate(root, null, null);
}
private boolean validate(TreeNode node, Integer low, Integer high) {
    if (node == null) return true;
    if ((low != null && node.val <= low) || (high != null && node.val >= high)) return false;
    return validate(node.left, low, node.val) && validate(node.right, node.val, high);
}

复杂度：时间 O(n)，空间 O(h)。

230. 二叉搜索树中第 K 小的元素

题目：返回 BST 中第 k 小的元素（k 从 1 开始）。

核心思路：中序遍历，计数到 k 时返回。

public int kthSmallest(TreeNode root, int k) {
    int[] count = new int[]{k};
    int[] res = new int[1];
    inorder(root, count, res);
    return res[0];
}
private void inorder(TreeNode node, int[] count, int[] res) {
    if (node == null) return;
    inorder(node.left, count, res);
    count[0]--;
    if (count[0] == 0) {
        res[0] = node.val;
        return;
    }
    inorder(node.right, count, res);
}

复杂度：时间 O(n)（最坏），空间 O(h)。

四、路径与构造（199、114、105、437）

199. 二叉树的右视图

题目：返回从右边看二叉树能看到的节点值（每层最右）。

核心思路：BFS 层序，记录每层最后一个节点；或 DFS 先右后左，当深度等于已收集数量时加入。

public List<Integer> rightSideView(TreeNode root) {
    List<Integer> res = new ArrayList<>();
    dfs(root, 0, res);
    return res;
}
private void dfs(TreeNode node, int depth, List<Integer> res) {
    if (node == null) return;
    if (depth == res.size()) res.add(node.val);
    dfs(node.right, depth + 1, res);
    dfs(node.left, depth + 1, res);
}

复杂度：时间 O(n)，空间 O(h)。

114. 二叉树展开为链表

题目：将二叉树按前序遍历顺序展开为单向链表（右指针指向下一个）。

核心思路：后序递归，将左子树展平并接入右子树位置，然后将原右子树接在左子树末尾。

public void flatten(TreeNode root) {
    if (root == null) return;
    flatten(root.left);
    flatten(root.right);
    TreeNode left = root.left;
    TreeNode right = root.right;
    root.left = null;
    root.right = left;
    TreeNode cur = root;
    while (cur.right != null) cur = cur.right;
    cur.right = right;
}

复杂度：时间 O(n)，空间 O(h)。

105. 从前序与中序遍历序列构造二叉树

题目：根据前序和中序数组构造二叉树（无重复值）。

核心思路：前序第一个为根，在中序中找到根的位置，递归构造左右子树。用哈希表优化定位。

public TreeNode buildTree(int[] preorder, int[] inorder) {
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < inorder.length; i++) map.put(inorder[i], i);
    return build(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1, map);
}
private TreeNode build(int[] preorder, int pLeft, int pRight,
                       int[] inorder, int iLeft, int iRight,
                       Map<Integer, Integer> map) {
    if (pLeft > pRight) return null;
    int rootVal = preorder[pLeft];
    TreeNode root = new TreeNode(rootVal);
    int idx = map.get(rootVal);
    int leftSize = idx - iLeft;
    root.left = build(preorder, pLeft + 1, pLeft + leftSize,
                      inorder, iLeft, idx - 1, map);
    root.right = build(preorder, pLeft + leftSize + 1, pRight,
                       inorder, idx + 1, iRight, map);
    return root;
}

复杂度：时间 O(n)，空间 O(n)。

437. 路径总和 III

题目：给定二叉树和目标值，求节点值之和等于目标值的路径总数（路径不必从根开始，也不用到叶）。

核心思路：前缀和 + DFS 回溯。用哈希表记录从根到当前节点的路径和出现次数，类似于"和为 K 的子数组"的树版本。

public int pathSum(TreeNode root, int targetSum) {
    Map<Long, Integer> prefix = new HashMap<>();
    prefix.put(0L, 1);
    return dfs(root, 0L, targetSum, prefix);
}
private int dfs(TreeNode node, long currentSum, int target, Map<Long, Integer> prefix) {
    if (node == null) return 0;
    currentSum += node.val;
    int count = prefix.getOrDefault(currentSum - target, 0);
    prefix.put(currentSum, prefix.getOrDefault(currentSum, 0) + 1);
    count += dfs(node.left, currentSum, target, prefix);
    count += dfs(node.right, currentSum, target, prefix);
    prefix.put(currentSum, prefix.get(currentSum) - 1); // 回溯
    return count;
}

复杂度：时间 O(n)，空间 O(n)。

五、最近公共祖先与最大路径和（236、124）

236. 二叉树的最近公共祖先

题目：给定两个节点 p、q，返回它们的最近公共祖先（LCA）。

核心思路：递归，若当前节点为 null 或等于 p/q 则返回当前节点；在左右子树中查找，若两边均非空则当前节点为 LCA，否则返回非空的一侧。

public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
    if (root == null || root == p || root == q) return root;
    TreeNode left = lowestCommonAncestor(root.left, p, q);
    TreeNode right = lowestCommonAncestor(root.right, p, q);
    if (left != null && right != null) return root;
    return left != null ? left : right;
}

复杂度：时间 O(n)，空间 O(h)。

124. 二叉树中的最大路径和

题目：路径可以从任意节点到任意节点，求最大路径和（路径至少包含一个节点）。

核心思路：递归计算每个节点的"最大贡献值"（即从该节点向下延伸能获得的最大和），同时全局更新以该节点为最高点的最大路径和（左贡献 + 右贡献 + 自身值）。注意贡献值为负数时取 0（不延伸）。

int maxSum = Integer.MIN_VALUE;
public int maxPathSum(TreeNode root) {
    maxGain(root);
    return maxSum;
}
private int maxGain(TreeNode node) {
    if (node == null) return 0;
    int leftGain = Math.max(0, maxGain(node.left));
    int rightGain = Math.max(0, maxGain(node.right));
    int currentPathSum = node.val + leftGain + rightGain;
    maxSum = Math.max(maxSum, currentPathSum);
    return node.val + Math.max(leftGain, rightGain);
}

复杂度：时间 O(n)，空间 O(h)。

六、对比与总结

题目	核心技巧	时间复杂度	空间复杂度	关键点
94 中序遍历	DFS（递归/迭代）	O(n)	O(h)	递归或显式栈
104 最大深度	递归分解	O(n)	O(h)	1 + max(left,right)
226 翻转二叉树	递归交换	O(n)	O(h)	先翻转子树再交换
101 对称二叉树	递归镜像比较	O(n)	O(h)	比较 t1.left vs t2.right
102 层序遍历	BFS（队列）	O(n)	O(n)	每层节点数控制
108 有序数组转 BST	分治构造	O(n)	O(log n)	取中间为根
98 验证 BST	上下界递归	O(n)	O(h)	传递 low/high
230 第 K 小元素	中序遍历	O(n)	O(h)	计数剪枝
199 右视图	DFS 先右后左	O(n)	O(h)	深度匹配列表大小
114 展开为链表	后序递归	O(n)	O(h)	左接右，右接原右
105 前中构造	分治+哈希	O(n)	O(n)	定位根位置
437 路径总和 III	前缀和+回溯	O(n)	O(n)	类似子数组和
236 最近公共祖先	递归查找	O(n)	O(h)	左右均非空则返回根
124 最大路径和	后序贡献计算	O(n)	O(h)	负数贡献取 0

总结心法：

二叉树题几乎都可以用递归解决，关键是明确递归函数的意义（返回值是什么，副作用是什么）。
对于路径类问题，常用"前缀和 + 回溯"或"全局最大值"方式。
构造类问题（如由遍历序列构造）依赖分治，用哈希表优化定位。
最近公共祖先和最大路径和是难点，但思路固定，熟记模板即可。

二分查找模块 — LeetCode 热门 100 题精讲（Java 向）

Tue, 21 Jul 2026 00:00:00 +0000

二分查找思想概述

二分查找（Binary Search）是算法中最基础的 O(log n) 查找技术，适用于 有序数组（或部分有序）中的查找、最值、边界定位等场景。其核心思想是 不断缩小搜索区间，通过比较中间元素与目标值的关系，排除一半区间。

虽然二分查找代码简短，但 边界条件（left < right vs left <= right） 和 区间收缩（left = mid + 1 vs left = mid） 极易出错。掌握一套稳定的模板至关重要：

// 基础模板：查找目标值（无重复）
int left = 0, right = nums.length - 1;
while (left <= right) {
    int mid = left + (right - left) / 2;
    if (nums[mid] == target) return mid;
    else if (nums[mid] < target) left = mid + 1;
    else right = mid - 1;
}
return -1;

LeetCode 热门 100 题中有六道二分经典题，覆盖了 标准二分、边界查找、旋转数组、二维矩阵、双数组 等多种变体。下面逐一拆解。

1. 搜索插入位置（LeetCode 35）

题目：给定排序数组和目标值，若找到则返回下标，若未找到则返回它应该插入的位置（保持有序）。

核心思路：标准二分，当 nums[mid] < target 时 left = mid + 1，否则 right = mid - 1。最终返回 left，它即为插入位置。

public int searchInsert(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) return mid;
        else if (nums[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return left;
}

复杂度：时间 O(log n)，空间 O(1)。

关键点：left 最终停在第一个大于等于 target 的位置，即插入位置；循环条件 <= 确保能处理所有情况。

2. 搜索二维矩阵（LeetCode 74）

题目：矩阵每行升序，且每行的第一个元素大于上一行的最后一个元素（即整体有序），判断目标是否存在。

核心思路：将二维矩阵视作一维有序数组，长度为 m * n，用标准二分，通过 mid / n 和 mid % n 映射到行列。

public boolean searchMatrix(int[][] matrix, int target) {
    if (matrix.length == 0) return false;
    int m = matrix.length, n = matrix[0].length;
    int left = 0, right = m * n - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        int val = matrix[mid / n][mid % n];
        if (val == target) return true;
        else if (val < target) left = mid + 1;
        else right = mid - 1;
    }
    return false;
}

复杂度：时间 O(log(mn))，空间 O(1)。

关键点：一维索引到二维坐标的映射是核心；此题也可用两次二分（先找行再找列），但一维映射更简洁。

3. 在排序数组中查找元素的第一个和最后一个位置（LeetCode 34）

题目：给定升序数组（可含重复元素），求目标值的起始和结束下标，不存在则返回 [-1, -1]。

核心思路：分别查找左边界（第一个 >= target）和右边界（最后一个 <= target）。可用两次二分，或封装一个函数 binarySearch(nums, target, isLeft) 控制收缩方向。

public int[] searchRange(int[] nums, int target) {
    int leftIdx = binarySearch(nums, target, true);
    int rightIdx = binarySearch(nums, target, false) - 1;
    if (leftIdx <= rightIdx && nums[leftIdx] == target) {
        return new int[]{leftIdx, rightIdx};
    }
    return new int[]{-1, -1};
}
private int binarySearch(int[] nums, int target, boolean isLeft) {
    int left = 0, right = nums.length - 1;
    int idx = nums.length; // 默认为长度（表示不存在）
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] > target || (isLeft && nums[mid] >= target)) {
            right = mid - 1;
            idx = mid;
        } else {
            left = mid + 1;
        }
    }
    return idx;
}

复杂度：时间 O(log n)，空间 O(1)。

关键点：左边界查找时，当 nums[mid] >= target 时收缩右边界，记录 mid；右边界查找可复用同一逻辑，只需返回 idx-1，或修改条件为 > 与 >= 的区分。

4. 搜索旋转排序数组（LeetCode 33）

题目：升序数组在某个下标处旋转（如 [0,1,2,4,5,6,7] 变为 [4,5,6,7,0,1,2]），判断目标是否存在。

核心思路：每次取 mid，根据 nums[left] 与 nums[mid] 的关系判断哪一侧是有序的。若目标值在有序区间内，则在该区间继续二分；否则在另一侧。

public int search(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) return mid;
        // 左半部分有序
        if (nums[left] <= nums[mid]) {
            if (target >= nums[left] && target < nums[mid]) right = mid - 1;
            else left = mid + 1;
        } else { // 右半部分有序
            if (target > nums[mid] && target <= nums[right]) left = mid + 1;
            else right = mid - 1;
        }
    }
    return -1;
}

复杂度：时间 O(log n)，空间 O(1)。

关键点：判断有序区间时使用 <=（处理重复元素时可扩展，但本题无重复）；通过比较目标是否在有序区间内决定移动方向。

5. 寻找旋转排序数组中的最小值（LeetCode 153）

题目：旋转升序数组（无重复），找出最小值。

核心思路：利用性质，最小值是唯一满足 nums[mid] > nums[right] 时在右半部分，否则在左半部分（包括 mid）。

public int findMin(int[] nums) {
    int left = 0, right = nums.length - 1;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] > nums[right]) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return nums[left];
}

复杂度：时间 O(log n)，空间 O(1)。

关键点：循环条件为 left < right，最终 left 指向最小值；比较对象是 nums[mid] 与 nums[right]，而不是 nums[left]，这样更稳定。

6. 寻找两个正序数组的中位数（LeetCode 4）

题目：给定两个升序数组，求它们合并后的中位数（O(log(m+n))）。

核心思路：在较短的数组上进行二分，确定两个数组的分割线，使得左右两侧元素个数相等（或差一），且左侧最大值 <= 右侧最小值。通过调整分割位置，直至满足条件。

public double findMedianSortedArrays(int[] nums1, int[] nums2) {
    if (nums1.length > nums2.length) return findMedianSortedArrays(nums2, nums1);
    int m = nums1.length, n = nums2.length;
    int left = 0, right = m;
    while (left <= right) {
        int i = left + (right - left) / 2;
        int j = (m + n + 1) / 2 - i;
        int left1 = (i == 0) ? Integer.MIN_VALUE : nums1[i-1];
        int right1 = (i == m) ? Integer.MAX_VALUE : nums1[i];
        int left2 = (j == 0) ? Integer.MIN_VALUE : nums2[j-1];
        int right2 = (j == n) ? Integer.MAX_VALUE : nums2[j];
        if (left1 <= right2 && left2 <= right1) {
            if ((m + n) % 2 == 0) {
                return (Math.max(left1, left2) + Math.min(right1, right2)) / 2.0;
            } else {
                return Math.max(left1, left2);
            }
        } else if (left1 > right2) {
            right = i - 1;
        } else {
            left = i + 1;
        }
    }
    return 0.0;
}

复杂度：时间 O(log(min(m,n)))，空间 O(1)。

关键点：将问题转化为"在两个有序数组中寻找一个分割点，使左右两侧元素总数平衡"；通过二分较短的数组，计算另一数组的分割位置；边界处理使用 MIN_VALUE 和 MAX_VALUE 简化判断。

六题对比与总结

题目	核心变体	循环条件	更新策略	特殊技巧
搜索插入位置	标准二分	`<=`	`left = mid+1, right = mid-1`	返回 `left`
搜索二维矩阵	整体有序	`<=`	同上	一维映射二维
查找首末位置	边界查找	`<=`	收缩方向控制	左右边界分离
搜索旋转数组	部分有序	`<=`	判断有序区间	分段确定目标位置
寻找最小值	旋转最小值	`<`	`left = mid+1 / right = mid`	比较 `nums[mid]` 与 `nums[right]`
两数组的中位数	双数组分割	`<=`	二分较短数组	边界值 + 奇偶判断

共同本质：二分查找的核心在于 “通过比较，排除不可能区间”。无论是旋转数组还是双数组，只要能将问题转化为"满足某个条件的元素位置"，二分就能派上用场。

总结心法：

确定搜索空间（数组下标区间）和循环条件（<= 或 <）。
确定比较对象（与 target 或与边界值）。
确定收缩规则（何时 left = mid+1，何时 right = mid-1）。
处理边界特殊情况（无重复、存在重复、是否越界）。

回溯模块 — LeetCode 热门 100 题精讲（Java 向）

Tue, 21 Jul 2026 00:00:00 +0000

回溯算法概述

回溯算法（Backtracking）本质是 暴力穷举 + 剪枝优化，它通过深度优先搜索（DFS）遍历所有可能的解空间，并在搜索过程中利用约束条件提前终止无效分支（剪枝）。回溯的核心模板是：

void backtrack(路径, 选择列表) {
    if (满足终止条件) {
        记录结果;
        return;
    }
    for (选择 : 选择列表) {
        做选择;
        backtrack(路径, 新的选择列表);
        撤销选择; // 回溯核心
    }
}

回溯算法适用于排列、组合、子集、分割、棋盘等经典问题。LeetCode 热门 100 题中有八道回溯题，覆盖了回溯的绝大多数应用场景。下面按逻辑分组逐一拆解。

一、子集与组合（78、39）

78. 子集

题目：给定不含重复元素的整数数组，返回所有可能的子集（幂集）。

核心思路：经典选/不选模型，或用 start 控制不回头遍历。每次递归都将当前路径加入结果，然后从 start 开始循环，选择下一个元素。

public List<List<Integer>> subsets(int[] nums) {
    List<List<Integer>> res = new ArrayList<>();
    backtrack(nums, 0, new ArrayList<>(), res);
    return res;
}
private void backtrack(int[] nums, int start, List<Integer> path, List<List<Integer>> res) {
    res.add(new ArrayList<>(path));
    for (int i = start; i < nums.length; i++) {
        path.add(nums[i]);
        backtrack(nums, i + 1, path, res);
        path.remove(path.size() - 1);
    }
}

复杂度：时间 O(n * 2^n)（每个子集复制开销），空间 O(n)（递归栈）。

关键点：res.add(new ArrayList<>(path)) 在每次递归开始时记录，包含空集；i + 1 保证元素不重复使用。

39. 组合总和

题目：给定无重复元素数组和目标值，找出所有和为目标值的组合（元素可重复使用）。

核心思路：与子集类似，但递归时传递 i 而非 i+1 以允许重复使用当前元素，并通过 target - nums[i] 剪枝（提前排序可进一步剪枝）。

public List<List<Integer>> combinationSum(int[] candidates, int target) {
    List<List<Integer>> res = new ArrayList<>();
    Arrays.sort(candidates); // 便于剪枝
    backtrack(candidates, target, 0, new ArrayList<>(), res);
    return res;
}
private void backtrack(int[] candidates, int target, int start, List<Integer> path, List<List<Integer>> res) {
    if (target == 0) {
        res.add(new ArrayList<>(path));
        return;
    }
    for (int i = start; i < candidates.length; i++) {
        if (candidates[i] > target) break; // 剪枝
        path.add(candidates[i]);
        backtrack(candidates, target - candidates[i], i, path, res); // 注意是 i 不是 i+1
        path.remove(path.size() - 1);
    }
}

复杂度：时间取决于解的数量（最坏指数级），空间 O(n)。

关键点：允许重复使用元素体现在递归参数 i 而非 i+1；排序后通过 candidates[i] > target 提前终止循环。

二、排列（46）

46. 全排列

题目：给定不含重复元素的数组，返回所有可能的全排列。

核心思路：使用 used[] 数组标记哪些元素已被选择。与组合不同的是，排列每次循环都从 0 开始，但跳过已使用的元素。

public List<List<Integer>> permute(int[] nums) {
    List<List<Integer>> res = new ArrayList<>();
    boolean[] used = new boolean[nums.length];
    backtrack(nums, used, new ArrayList<>(), res);
    return res;
}
private void backtrack(int[] nums, boolean[] used, List<Integer> path, List<List<Integer>> res) {
    if (path.size() == nums.length) {
        res.add(new ArrayList<>(path));
        return;
    }
    for (int i = 0; i < nums.length; i++) {
        if (used[i]) continue;
        used[i] = true;
        path.add(nums[i]);
        backtrack(nums, used, path, res);
        path.remove(path.size() - 1);
        used[i] = false;
    }
}

复杂度：时间 O(n * n!)，空间 O(n)。

关键点：排列与组合的本质区别在于是否关注顺序；排列用 used 数组，组合用 start 索引。

三、字符串映射与剪枝（17、22）

17. 电话号码的字母组合

题目：给定数字字符串（2-9），返回其能表示的所有字母组合（如电话键盘）。

核心思路：构建数字到字母串的映射，DFS 遍历 digits，每层取当前数字对应的字母进行拼接。

public List<String> letterCombinations(String digits) {
    List<String> res = new ArrayList<>();
    if (digits == null || digits.length() == 0) return res;
    String[] map = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
    backtrack(digits, map, 0, new StringBuilder(), res);
    return res;
}
private void backtrack(String digits, String[] map, int idx, StringBuilder sb, List<String> res) {
    if (idx == digits.length()) {
        res.add(sb.toString());
        return;
    }
    String letters = map[digits.charAt(idx) - '0'];
    for (char c : letters.toCharArray()) {
        sb.append(c);
        backtrack(digits, map, idx + 1, sb, res);
        sb.deleteCharAt(sb.length() - 1);
    }
}

复杂度：时间 O(4^n * n)，空间 O(n)。

关键点：这是典型的"多叉树"回溯，每一层的分支数取决于按键对应的字母数。

22. 括号生成

题目：给定 n，生成所有可能的且有效的括号组合（n 对括号）。

核心思路：维持左右括号数量，left 和 right 都等于 n 时终止。约束条件：左括号数不超过 n，右括号数不超过左括号数。

public List<String> generateParenthesis(int n) {
    List<String> res = new ArrayList<>();
    backtrack(n, 0, 0, new StringBuilder(), res);
    return res;
}
private void backtrack(int n, int left, int right, StringBuilder sb, List<String> res) {
    if (left == n && right == n) {
        res.add(sb.toString());
        return;
    }
    if (left < n) {
        sb.append('(');
        backtrack(n, left + 1, right, sb, res);
        sb.deleteCharAt(sb.length() - 1);
    }
    if (right < left) {
        sb.append(')');
        backtrack(n, left, right + 1, sb, res);
        sb.deleteCharAt(sb.length() - 1);
    }
}

复杂度：时间 O(4^n / √n)（卡特兰数），空间 O(n)。

关键点：right < left 是核心剪枝条件，保证括号有效性；这也是回溯中"剪枝"的经典体现。

四、矩阵回溯（79）

79. 单词搜索

题目：给定二维字符网格和单词，判断单词是否存在于网格中（相邻格子水平或垂直连接，不能重复使用同一格）。

核心思路：遍历每个格子作为起点，DFS 搜索匹配单词。用 board[i][j] = '#' 或 visited 数组标记已访问，匹配失败则回溯还原。

public boolean exist(char[][] board, String word) {
    int m = board.length, n = board[0].length;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (dfs(board, word, 0, i, j)) return true;
        }
    }
    return false;
}
private boolean dfs(char[][] board, String word, int idx, int i, int j) {
    if (idx == word.length()) return true;
    if (i < 0 || i >= board.length || j < 0 || j >= board[0].length) return false;
    if (board[i][j] != word.charAt(idx)) return false;
    char temp = board[i][j];
    board[i][j] = '#'; // 标记已访问
    boolean found = dfs(board, word, idx + 1, i - 1, j) ||
                    dfs(board, word, idx + 1, i + 1, j) ||
                    dfs(board, word, idx + 1, i, j - 1) ||
                    dfs(board, word, idx + 1, i, j + 1);
    board[i][j] = temp; // 回溯还原
    return found;
}

复杂度：时间 O(m * n * 3^L)（L 为单词长度，分支因子为 3 因为不会往回走），空间 O(L)。

关键点：矩阵回溯需要在递归前"标记"当前格子，递归后"还原"，防止重复使用；四个方向用短路或（||）连接。

五、分割（131）

131. 分割回文串

题目：给定字符串，将其分割成若干子串，使每个子串都是回文串，返回所有可能的分割方案。

核心思路：从起始位置 start 开始，枚举结束位置 end，若子串 [start, end] 是回文，则将其加入路径，递归处理剩余部分。

public List<List<String>> partition(String s) {
    List<List<String>> res = new ArrayList<>();
    backtrack(s, 0, new ArrayList<>(), res);
    return res;
}
private void backtrack(String s, int start, List<String> path, List<List<String>> res) {
    if (start == s.length()) {
        res.add(new ArrayList<>(path));
        return;
    }
    for (int end = start; end < s.length(); end++) {
        if (isPalindrome(s, start, end)) {
            path.add(s.substring(start, end + 1));
            backtrack(s, end + 1, path, res);
            path.remove(path.size() - 1);
        }
    }
}
private boolean isPalindrome(String s, int left, int right) {
    while (left < right) {
        if (s.charAt(left++) != s.charAt(right--)) return false;
    }
    return true;
}

复杂度：时间最坏 O(n * 2^n)，空间 O(n)。

关键点：分割问题的"选择列表"是当前起点到末尾的所有回文子串；用双指针判断回文，也可用 DP 预处理优化。

六、棋盘（51）

51. N 皇后

题目：在 n×n 棋盘上放置 n 个皇后，使其不能互相攻击（不同行、列、对角线），返回所有合法摆法。

核心思路：逐行放置皇后，用三个集合分别记录已占用的列、主对角线（row - col）、副对角线（row + col）。每行在可放置的列中尝试。

public List<List<String>> solveNQueens(int n) {
    List<List<String>> res = new ArrayList<>();
    boolean[] cols = new boolean[n];
    boolean[] diag1 = new boolean[2 * n - 1]; // row - col + n - 1
    boolean[] diag2 = new boolean[2 * n - 1]; // row + col
    char[][] board = new char[n][n];
    for (char[] row : board) Arrays.fill(row, '.');
    backtrack(n, 0, cols, diag1, diag2, board, res);
    return res;
}
private void backtrack(int n, int row, boolean[] cols, boolean[] diag1, boolean[] diag2,
                       char[][] board, List<List<String>> res) {
    if (row == n) {
        List<String> list = new ArrayList<>();
        for (char[] r : board) list.add(new String(r));
        res.add(list);
        return;
    }
    for (int col = 0; col < n; col++) {
        int d1 = row - col + n - 1;
        int d2 = row + col;
        if (cols[col] || diag1[d1] || diag2[d2]) continue;
        board[row][col] = 'Q';
        cols[col] = diag1[d1] = diag2[d2] = true;
        backtrack(n, row + 1, cols, diag1, diag2, board, res);
        board[row][col] = '.';
        cols[col] = diag1[d1] = diag2[d2] = false;
    }
}

复杂度：时间 O(n!)，空间 O(n²)（棋盘存储）。

关键点：主对角线 row - col 为定值，副对角线 row + col 为定值；通过偏移 + n - 1 保证索引非负。

八题对比与总结

题目	解空间类型	核心剪枝/去重	递归参数	时间复杂度
78 子集	组合/子集	`start` 去重	`start`	O(n * 2^n)
39 组合总和	组合（可重复）	排序 + `candidate > target`	`start`（允许自身）	O(解的数量)
46 全排列	排列	`used[]` 标记	`used[]`	O(n * n!)
17 电话组合	映射多叉树	无（天然无重复）	`idx`（位置）	O(4^n * n)
22 括号生成	约束生成	`right < left`	`left, right` 计数	O(4^n / √n)
79 单词搜索	矩阵路径	原地标记 `#`	`i, j` 坐标	O(mn * 3^L)
131 回文分割	分割	回文检测	`start` 起点	O(n * 2^n)
51 N 皇后	棋盘放置	列/对角线集合	`row` 行号	O(n!)

共同本质：回溯的核心是 “做出选择 → 递归 → 撤销选择”。无论问题形式如何，都可抽象为"遍历决策树"，通过约束条件剪枝。

总结心法：

确定递归函数的参数（通常是"当前处理位置"或"剩余目标"）。
确定终止条件（满足要求时记录结果）。
确定选择列表（当前层有哪些可选分支）。
确定剪枝条件（跳过不符合要求的分支）。
确定是否需要去重（组合用 start，排列用 used）。

图论模块 — LeetCode 热门 100 题精讲（Java 向）

Tue, 21 Jul 2026 00:00:00 +0000

图论问题概述

图论是算法面试中极具区分度的模块，它涵盖了矩阵网格（本质是图的特殊形式）、有向图、无向图以及树形结构的扩展。图论题的核心技巧包括：

DFS / BFS：用于连通性检测、路径搜索、染色标记等。
拓扑排序：解决有向图的依赖关系问题，如课程安排。
并查集（Union-Find）：高效处理动态连通性问题。
前缀树（Trie）：多叉树的特殊应用，用于字符串高效查找。

LeetCode 热门 100 题中有四道图论经典题：200. 岛屿数量（网格 DFS/BFS）、994. 腐烂的橘子（多源 BFS）、207. 课程表（拓扑排序）、208. 实现 Trie（前缀树）（多叉树设计）。下面逐一剖析。

1. 岛屿数量（LeetCode 200）

题目：给定一个由 ‘1’（陆地）和 ‘0’（水）组成的二维网格，计算岛屿数量。岛屿被水包围，且水平或垂直相邻的陆地视为同一岛屿。

核心思路：遍历网格，每遇到一个 ‘1’ 就启动 DFS/BFS，将该岛屿所有相邻的 ‘1’ 标记为已访问（变为 ‘0’），岛屿计数加一。

DFS 实现：

public int numIslands(char[][] grid) {
    if (grid == null || grid.length == 0) return 0;
    int m = grid.length, n = grid[0].length;
    int count = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == '1') {
                count++;
                dfs(grid, i, j);
            }
        }
    }
    return count;
}
private void dfs(char[][] grid, int i, int j) {
    if (i < 0 || i >= grid.length || j < 0 || j >= grid[0].length || grid[i][j] == '0') return;
    grid[i][j] = '0'; // 标记已访问
    dfs(grid, i - 1, j);
    dfs(grid, i + 1, j);
    dfs(grid, i, j - 1);
    dfs(grid, i, j + 1);
}

复杂度：时间 O(mn)，空间 O(mn)（递归栈最坏情况）。

关键点：原地修改 grid 避免 visited 数组；也可以使用 BFS（队列）避免递归深度过大。

2. 腐烂的橘子（LeetCode 994）

题目：给定网格，每个格子可能是新鲜橘子（1）、腐烂橘子（2）或空（0）。每分钟腐烂橘子会将上下左右的新鲜橘子腐烂。求全部腐烂所需的最短分钟数，若无法全部腐烂则返回 -1。

核心思路：多源 BFS。将所有初始腐烂橘子入队，同时统计新鲜橘子总数。BFS 逐层扩展，每扩展一层即增加一分钟。当新鲜橘子数为 0 时返回层数；若 BFS 结束后仍有新鲜橘子则返回 -1。

public int orangesRotting(int[][] grid) {
    int m = grid.length, n = grid[0].length;
    Queue<int[]> q = new LinkedList<>();
    int fresh = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == 2) q.offer(new int[]{i, j});
            else if (grid[i][j] == 1) fresh++;
        }
    }
    if (fresh == 0) return 0;
    int minutes = 0;
    int[][] dirs = {{-1,0},{1,0},{0,-1},{0,1}};
    while (!q.isEmpty() && fresh > 0) {
        int size = q.size();
        minutes++;
        for (int i = 0; i < size; i++) {
            int[] cell = q.poll();
            for (int[] dir : dirs) {
                int x = cell[0] + dir[0];
                int y = cell[1] + dir[1];
                if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 1) {
                    grid[x][y] = 2;
                    fresh--;
                    q.offer(new int[]{x, y});
                }
            }
        }
    }
    return fresh == 0 ? minutes : -1;
}

复杂度：时间 O(mn)，空间 O(mn)。

关键点：多源 BFS 的层数即为分钟数；用 fresh 计数器提前终止。

3. 课程表（LeetCode 207）

题目：给定课程数量 numCourses 和先修关系数组 prerequisites，其中 prerequisites[i] = [a, b] 表示学 a 前必须先学 b。判断是否可以完成所有课程（即图是否有环）。

核心思路：拓扑排序（Kahn 算法）。构建邻接表和入度数组，将所有入度为 0 的节点入队，依次弹出并减少其邻接节点的入度，若某个节点入度变为 0 则入队。若最终入队节点数等于课程总数则无环，否则有环。

public boolean canFinish(int numCourses, int[][] prerequisites) {
    List<Integer>[] graph = new ArrayList[numCourses];
    int[] indegree = new int[numCourses];
    for (int i = 0; i < numCourses; i++) graph[i] = new ArrayList<>();
    for (int[] edge : prerequisites) {
        graph[edge[1]].add(edge[0]);
        indegree[edge[0]]++;
    }
    Queue<Integer> q = new LinkedList<>();
    for (int i = 0; i < numCourses; i++) if (indegree[i] == 0) q.offer(i);
    int count = 0;
    while (!q.isEmpty()) {
        int cur = q.poll();
        count++;
        for (int next : graph[cur]) {
            indegree[next]--;
            if (indegree[next] == 0) q.offer(next);
        }
    }
    return count == numCourses;
}

复杂度：时间 O(V+E)，空间 O(V+E)。

关键点：拓扑排序是检测有向图环的标准方法；也可用 DFS 三色标记检测环。

4. 实现 Trie（前缀树）（LeetCode 208）

题目：实现 Trie 类，支持插入单词、搜索单词、搜索前缀。

核心思路：Trie 是多叉树，每个节点包含一个长度为 26 的子节点数组和一个布尔标志 isEnd。插入时逐字符创建节点，搜索时逐字符向下查找。

class Trie {
    class TrieNode {
        TrieNode[] children = new TrieNode[26];
        boolean isEnd;
    }
    private TrieNode root;
    public Trie() { root = new TrieNode(); }
    public void insert(String word) {
        TrieNode node = root;
        for (char c : word.toCharArray()) {
            int idx = c - 'a';
            if (node.children[idx] == null) node.children[idx] = new TrieNode();
            node = node.children[idx];
        }
        node.isEnd = true;
    }
    public boolean search(String word) {
        TrieNode node = searchPrefix(word);
        return node != null && node.isEnd;
    }
    public boolean startsWith(String prefix) {
        return searchPrefix(prefix) != null;
    }
    private TrieNode searchPrefix(String prefix) {
        TrieNode node = root;
        for (char c : prefix.toCharArray()) {
            int idx = c - 'a';
            if (node.children[idx] == null) return null;
            node = node.children[idx];
        }
        return node;
    }
}

复杂度：插入和搜索的时间均为 O(L)（L 为单词长度），空间 O(总字符数 * 26)。

关键点：Trie 本质上是一个多叉树，它是处理字符串集合的高效结构，常用于自动补全、单词搜索等。

四题对比与总结

题目	图类型	核心技巧	时间复杂度	空间复杂度	关键点
岛屿数量	网格无向图	DFS/BFS 标记	O(mn)	O(mn)	原地修改染色
腐烂的橘子	网格多源 BFS	多源 BFS 层数	O(mn)	O(mn)	多源同时扩展
课程表	有向图	拓扑排序（入度）	O(V+E)	O(V+E)	检测有环
前缀树	多叉树	节点数组 + isEnd	O(L)	O(26×N)	字符串快速查找

共同本质：图论题的核心是 状态传播。DFS/BFS 用于扩散信息（染色、腐烂、依赖传递），拓扑排序处理先后顺序，前缀树本质上是树形结构但常归入图论范畴。

总结心法：

遇到网格连通性 → DFS/BFS 标记。
遇到多起点均匀扩散 → 多源 BFS。
遇到依赖关系 → 拓扑排序（入度队列）。
遇到大量字符串查找 → Trie 前缀树。

矩阵模块 — LeetCode 热门 100 题精讲（Java 向）

Mon, 20 Jul 2026 00:00:00 +0000

矩阵问题概述

矩阵（二维数组）是数组的进阶形态，其操作往往涉及行与列的联动。相比于普通一维数组，矩阵题更强调下标映射和原地修改，常见技巧包括：

原地标记：利用数组自身元素（如第一行、第一列）作为标记，避免额外空间。
分层模拟：按圈层（或边界）逐层处理，常用于螺旋遍历、旋转等。
转置 + 翻转：通过两次基本变换合成复杂旋转。
二分搜索或单调性剪枝：利用矩阵的排序特性快速查找。

LeetCode 热门 100 题中，有四道矩阵经典题覆盖了上述各类技巧：73. 矩阵置零（原地标记）、54. 螺旋矩阵（分层模拟）、48. 旋转图像（转置+翻转）、240. 搜索二维矩阵 II（单调性剪枝）。下面逐一拆解。

1. 矩阵置零（LeetCode 73）

题目：给定一个 m×n 的矩阵，如果一个元素为 0，则将其所在行和列的所有元素都设为 0。要求使用原地算法（空间复杂度 O(1)）。

暴力法：复制一个原矩阵，遍历原矩阵发现 0 就去复制矩阵中置零，最后复制回来，空间 O(mn)。

优化思路（原地标记）：利用矩阵的第一行和第一列作为"标记位"，记录哪些行、列需要置零。但需提前记录第一行和第一列本身是否包含 0，以免被覆盖后丢失信息。

具体步骤：

检查第一行和第一列是否有 0，分别用 rowZero 和 colZero 布尔值记录。
遍历矩阵（除第一行第一列外），若 matrix[i][j] == 0，则将 matrix[i][0] = 0 和 matrix[0][j] = 0 作为标记。
再次遍历（除第一行第一列外），若 matrix[i][0] == 0 或 matrix[0][j] == 0，则将 matrix[i][j] = 0。
根据 rowZero 和 colZero 决定是否将第一行、第一列置零。

public void setZeroes(int[][] matrix) {
    int m = matrix.length, n = matrix[0].length;
    boolean rowZero = false, colZero = false;
    for (int i = 0; i < m; i++) {
        if (matrix[i][0] == 0) colZero = true;
    }
    for (int j = 0; j < n; j++) {
        if (matrix[0][j] == 0) rowZero = true;
    }
    for (int i = 1; i < m; i++) {
        for (int j = 1; j < n; j++) {
            if (matrix[i][j] == 0) {
                matrix[i][0] = 0;
                matrix[0][j] = 0;
            }
        }
    }
    for (int i = 1; i < m; i++) {
        for (int j = 1; j < n; j++) {
            if (matrix[i][0] == 0 || matrix[0][j] == 0) {
                matrix[i][j] = 0;
            }
        }
    }
    if (colZero) {
        for (int i = 0; i < m; i++) matrix[i][0] = 0;
    }
    if (rowZero) {
        for (int j = 0; j < n; j++) matrix[0][j] = 0;
    }
}

复杂度：时间 O(mn)，空间 O(1)。

关键点：必须提前保存第一行第一列的状态，否则标记过程会污染原始信息；置零顺序先内后外，保证标记不被覆盖。

2. 螺旋矩阵（LeetCode 54）

题目：给定一个 m×n 矩阵，按顺时针螺旋顺序返回矩阵中的所有元素。

优化思路（分层模拟）：定义四个边界：top、bottom、left、right，按顺序遍历上、右、下、左四条边，每遍历完一条边就收缩对应边界，直到边界交错。

public List<Integer> spiralOrder(int[][] matrix) {
    List<Integer> result = new ArrayList<>();
    if (matrix.length == 0) return result;
    int top = 0, bottom = matrix.length - 1;
    int left = 0, right = matrix[0].length - 1;
    while (top <= bottom && left <= right) {
        for (int j = left; j <= right; j++) result.add(matrix[top][j]);
        top++;
        for (int i = top; i <= bottom; i++) result.add(matrix[i][right]);
        right--;
        if (top <= bottom) {
            for (int j = right; j >= left; j--) result.add(matrix[bottom][j]);
            bottom--;
        }
        if (left <= right) {
            for (int i = bottom; i >= top; i--) result.add(matrix[i][left]);
            left++;
        }
    }
    return result;
}

复杂度：时间 O(mn)，空间 O(1)（除输出外）。

关键点：每遍历完一条边立即收缩对应边界，并在下边和左边遍历前检查边界是否仍然有效，避免重复添加。

3. 旋转图像（LeetCode 48）

题目：给定一个 n×n 的二维矩阵，将其顺时针旋转 90 度。要求原地旋转。

暴力法：创建新矩阵，按映射关系填入，空间 O(n²)。

优化思路（转置 + 水平翻转）：顺时针旋转 90 度等价于先对矩阵进行转置（行变列），再对每一行进行水平翻转。这两步都可以原地完成。

public void rotate(int[][] matrix) {
    int n = matrix.length;
    // 转置
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            int temp = matrix[i][j];
            matrix[i][j] = matrix[j][i];
            matrix[j][i] = temp;
        }
    }
    // 水平翻转
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n/2; j++) {
            int temp = matrix[i][j];
            matrix[i][j] = matrix[i][n-1-j];
            matrix[i][n-1-j] = temp;
        }
    }
}

复杂度：时间 O(n²)，空间 O(1)。

关键点：转置时内层循环从 i 开始避免交换两次；水平翻转每行只需遍历前一半。

4. 搜索二维矩阵 II（LeetCode 240）

题目：在一个 m×n 矩阵中搜索目标值，矩阵的每行从左到右升序，每列从上到下升序。要求时间复杂度 O(m+n)。

暴力法：遍历所有元素 O(mn)。

优化思路（Z 字形搜索）：从矩阵的右上角（或左下角）开始。若当前值等于目标，返回 true；若当前值大于目标，则向左移动（列减 1），因为该列下方元素都更大，不可能包含目标；若当前值小于目标，则向下移动（行加 1），因为该行左边元素都更小。每一步排除一行或一列，直到越界。

public boolean searchMatrix(int[][] matrix, int target) {
    if (matrix.length == 0) return false;
    int m = matrix.length, n = matrix[0].length;
    int row = 0, col = n - 1;
    while (row < m && col >= 0) {
        if (matrix[row][col] == target) return true;
        else if (matrix[row][col] > target) col--;
        else row++;
    }
    return false;
}

复杂度：时间 O(m+n)，空间 O(1)。

关键点：利用矩阵的排序特性，每次比较都能排除一整行或一整列；起始点选右上角或左下角均可。

四题对比与启发

题目	核心技巧	时间复杂度	空间复杂度	特殊要求
矩阵置零	原地标记（第一行第一列作标记）	O(mn)	O(1)	原地修改
螺旋矩阵	分层模拟（四边界收缩）	O(mn)	O(1)	顺序输出
旋转图像	转置 + 水平翻转	O(n²)	O(1)	原地旋转
搜索二维矩阵 II	Z 字形剪枝（右上角开始）	O(m+n)	O(1)	利用行列有序

共同本质：矩阵题的优化核心在于 “信息复用” 和 “空间节约”。置零题用第一行第一列作标记避免额外数组；螺旋题通过边界变量逐步收缩避免重复访问；旋转题通过两次基本变换合成复杂操作；搜索题则利用有序性进行单向移动。

不同侧重：

73：用矩阵自身存储辅助信息，前提是必须保留原始标志位。
54：注重边界控制和方向切换，属于纯模拟。
48：拆分变换步骤，利用转置和翻转的结合。
240：利用元素之间的偏序关系，每次排除一整行/列。

总结：矩阵模块的核心心法

矩阵题的核心在于"将二维操作转化为一维或常量操作"。无论是用一行/列作标记，还是按圈层分解，亦或是拆分为简单变换的组合，目的都是避免 O(n²) 的额外空间或冗余遍历。

解题时的思考路径：

若需要记录整行/整列的状态，考虑用第一行/列作标记（但注意保护原信息）。

若需要按顺序遍历所有元素，使用边界收缩法（螺旋）。

若需要旋转或镜像，分解为转置 + 翻转的组合。

若需要快速查找且矩阵具有有序性，利用其单调性进行单方向移动。

掌握这四道题，矩阵类问题的基础技法便已覆盖过半，遇到变形题（如螺旋矩阵 II、对角线遍历等）也能快速迁移。

链表模块 — LeetCode 热门 100 题精讲（Java 向）

Mon, 20 Jul 2026 00:00:00 +0000

链表问题概述

链表是线性表的一种链式存储结构，其节点在内存中不连续，通过指针链接。链表题的核心是 指针操作，常涉及头结点的处理、边界条件、环检测、合并、反转、复制等。由于链表不能随机访问，很多操作只能顺序遍历，因此时间复杂度的优化往往依赖于双指针、递归或借助额外数据结构（如哈希表）。

LeetCode 热门 100 题中共有 14 道链表题，覆盖了链表操作的几乎所有经典场景。按照技巧分类，可分为以下几组：

反转与变形：206. 反转链表、234. 回文链表、24. 两两交换链表中的节点、25. K 个一组翻转链表
双指针/快慢指针：141. 环形链表、142. 环形链表 II、160. 相交链表、19. 删除链表的倒数第 N 个结点
合并与加法：21. 合并两个有序链表、2. 两数相加、23. 合并 K 个升序链表
复杂链表操作：138. 随机链表的复制、148. 排序链表
设计类：146. LRU 缓存（哈希表 + 双向链表）

下面按组分别展开，先介绍共性思路，再逐题讲解关键代码和注意点。

一、反转与变形

反转链表是基础操作，其他变形（回文、交换、K 组翻转）往往在反转的基础上增加预处理或分段处理。

206. 反转链表

题目：反转一个单链表。

核心思路：迭代法，维护三个指针 prev、curr、next，逐个改变 curr.next 指向 prev，然后前进。

public ListNode reverseList(ListNode head) {
    ListNode prev = null;
    ListNode curr = head;
    while (curr != null) {
        ListNode nextTemp = curr.next;
        curr.next = prev;
        prev = curr;
        curr = nextTemp;
    }
    return prev;
}

复杂度：时间 O(n)，空间 O(1)。

关键点：必须保存 curr.next 否则断链；返回 prev 成为新头。

234. 回文链表

题目：判断链表是否为回文。要求 O(n) 时间 O(1) 空间。

核心思路：

快慢指针找中点。
反转后半部分链表。
比较前半部分和反转后的后半部分。

public boolean isPalindrome(ListNode head) {
    if (head == null) return true;
    ListNode slow = head, fast = head;
    while (fast.next != null && fast.next.next != null) {
        slow = slow.next;
        fast = fast.next.next;
    }
    ListNode second = reverseList(slow.next);
    ListNode p1 = head, p2 = second;
    while (p2 != null) {
        if (p1.val != p2.val) return false;
        p1 = p1.next;
        p2 = p2.next;
    }
    return true;
}

复杂度：时间 O(n)，空间 O(1)。

关键点：快慢指针找中点时，slow 指向前半部分最后一个节点；反转后半部分后比较，无需恢复。

24. 两两交换链表中的节点

题目：给定链表，两两交换相邻节点，不能改值。

核心思路：迭代使用虚拟头结点，三个节点一组操作。

public ListNode swapPairs(ListNode head) {
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    ListNode prev = dummy;
    while (prev.next != null && prev.next.next != null) {
        ListNode first = prev.next;
        ListNode second = first.next;
        first.next = second.next;
        second.next = first;
        prev.next = second;
        prev = first;
    }
    return dummy.next;
}

复杂度：时间 O(n)，空间 O(1)。

关键点：虚拟头结点统一处理；注意指针移动顺序。

25. K 个一组翻转链表

题目：每 K 个节点一组翻转，不足 K 个保持原样。

核心思路：先检查剩余节点数是否 >= K，然后调用反转子函数，并连接前后部分。

public ListNode reverseKGroup(ListNode head, int k) {
    if (head == null) return null;
    ListNode tail = head;
    for (int i = 0; i < k; i++) {
        if (tail == null) return head;
        tail = tail.next;
    }
    ListNode newHead = reverse(head, tail);
    head.next = reverseKGroup(tail, k);
    return newHead;
}
private ListNode reverse(ListNode head, ListNode tail) {
    ListNode prev = null;
    ListNode curr = head;
    while (curr != tail) {
        ListNode next = curr.next;
        curr.next = prev;
        prev = curr;
        curr = next;
    }
    return prev;
}

复杂度：时间 O(n)，空间 O(1) 或递归栈 O(n/k)。

关键点：先定位当前组的尾部（tail），翻转区间为 [head, tail)。

二、双指针 / 快慢指针

141. 环形链表

题目：判断链表是否有环。

核心思路：快慢指针，快指针每次两步，慢指针一步，若有环则相遇。

public boolean hasCycle(ListNode head) {
    if (head == null) return false;
    ListNode slow = head, fast = head.next;
    while (slow != fast) {
        if (fast == null || fast.next == null) return false;
        slow = slow.next;
        fast = fast.next.next;
    }
    return true;
}

复杂度：时间 O(n)，空间 O(1)。

142. 环形链表 II

题目：返回环的入口节点，无环返回 null。

核心思路：快慢指针相遇后，将慢指针重置到头，快指针在相遇点，两者同步走，再次相遇点即为环入口。

public ListNode detectCycle(ListNode head) {
    ListNode slow = head, fast = head;
    while (fast != null && fast.next != null) {
        slow = slow.next;
        fast = fast.next.next;
        if (slow == fast) break;
    }
    if (fast == null || fast.next == null) return null;
    slow = head;
    while (slow != fast) {
        slow = slow.next;
        fast = fast.next;
    }
    return slow;
}

复杂度：时间 O(n)，空间 O(1)。

160. 相交链表

题目：找到两个链表相交的起始节点，不相交返回 null。

核心思路：双指针分别从两个链表头走，走完自己的链表后切换到对方链表，若相交则在第二次遍历时相遇。

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
    ListNode a = headA, b = headB;
    while (a != b) {
        a = (a == null) ? headB : a.next;
        b = (b == null) ? headA : b.next;
    }
    return a;
}

复杂度：时间 O(m+n)，空间 O(1)。

19. 删除链表的倒数第 N 个结点

题目：删除链表的倒数第 n 个节点，并返回头结点。

public ListNode removeNthFromEnd(ListNode head, int n) {
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    ListNode fast = dummy, slow = dummy;
    for (int i = 0; i <= n; i++) fast = fast.next;
    while (fast != null) {
        slow = slow.next;
        fast = fast.next;
    }
    slow.next = slow.next.next;
    return dummy.next;
}

复杂度：时间 O(n)，空间 O(1)。

关键点：使用虚拟头结点方便删除头结点；快指针先走 n+1 步，使 slow 指向待删节点的前驱。

三、合并与加法

21. 合并两个有序链表

public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
    ListNode dummy = new ListNode(0);
    ListNode cur = dummy;
    while (list1 != null && list2 != null) {
        if (list1.val < list2.val) {
            cur.next = list1;
            list1 = list1.next;
        } else {
            cur.next = list2;
            list2 = list2.next;
        }
        cur = cur.next;
    }
    cur.next = (list1 != null) ? list1 : list2;
    return dummy.next;
}

复杂度：时间 O(m+n)，空间 O(1)。

2. 两数相加

题目：两个非空链表表示非负整数（逆序存储），求它们的和并逆序返回。

public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
    ListNode dummy = new ListNode(0);
    ListNode cur = dummy;
    int carry = 0;
    while (l1 != null || l2 != null || carry != 0) {
        int sum = carry;
        if (l1 != null) { sum += l1.val; l1 = l1.next; }
        if (l2 != null) { sum += l2.val; l2 = l2.next; }
        carry = sum / 10;
        cur.next = new ListNode(sum % 10);
        cur = cur.next;
    }
    return dummy.next;
}

复杂度：时间 O(max(m,n))，空间 O(max(m,n))（输出链表）。

23. 合并 K 个升序链表

核心思路：优先队列（小顶堆）每次取出最小节点接入。

public ListNode mergeKLists(ListNode[] lists) {
    if (lists == null || lists.length == 0) return null;
    PriorityQueue<ListNode> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a.val));
    for (ListNode node : lists) if (node != null) pq.offer(node);
    ListNode dummy = new ListNode(0);
    ListNode cur = dummy;
    while (!pq.isEmpty()) {
        ListNode node = pq.poll();
        cur.next = node;
        cur = cur.next;
        if (node.next != null) pq.offer(node.next);
    }
    return dummy.next;
}

复杂度：时间 O(N log K)，空间 O(K)。

四、复杂链表操作

138. 随机链表的复制

核心思路：三步法（原地复制）：

在每个原节点后插入一个复制节点。
设置复制节点的 random 指针：copy.random = original.random.next。
分离原链表和复制链表。

public Node copyRandomList(Node head) {
    if (head == null) return null;
    Node cur = head;
    while (cur != null) {
        Node copy = new Node(cur.val);
        copy.next = cur.next;
        cur.next = copy;
        cur = copy.next;
    }
    cur = head;
    while (cur != null) {
        if (cur.random != null)
            cur.next.random = cur.random.next;
        cur = cur.next.next;
    }
    Node newHead = head.next;
    cur = head;
    while (cur != null) {
        Node copy = cur.next;
        cur.next = copy.next;
        cur = cur.next;
        if (cur != null) copy.next = cur.next;
    }
    return newHead;
}

复杂度：时间 O(n)，空间 O(1)（除输出外）。

148. 排序链表

核心思路：自底向上归并排序（迭代），先统计长度，然后按步长 1,2,4… 合并。

public ListNode sortList(ListNode head) {
    if (head == null || head.next == null) return head;
    int len = 0;
    ListNode cur = head;
    while (cur != null) { len++; cur = cur.next; }
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    for (int step = 1; step < len; step <<= 1) {
        ListNode prev = dummy;
        cur = dummy.next;
        while (cur != null) {
            ListNode left = cur;
            ListNode right = split(left, step);
            cur = split(right, step);
            prev.next = mergeTwoLists(left, right);
            while (prev.next != null) prev = prev.next;
        }
    }
    return dummy.next;
}
private ListNode split(ListNode head, int step) {
    if (head == null) return null;
    for (int i = 1; head.next != null && i < step; i++) head = head.next;
    ListNode right = head.next;
    head.next = null;
    return right;
}

复杂度：时间 O(n log n)，空间 O(1)。

五、设计类

146. LRU 缓存

题目：实现 LRU（最近最少使用）缓存，get 和 put 必须 O(1)。

核心思路：使用双向链表维护访问顺序（头部为最近使用），配合哈希表存储 key 到节点的映射。

class LRUCache {
    class DLinkedNode {
        int key, value;
        DLinkedNode prev, next;
        DLinkedNode(int k, int v) { key = k; value = v; }
    }
    private Map<Integer, DLinkedNode> cache = new HashMap<>();
    private int size, capacity;
    private DLinkedNode head, tail;

    public LRUCache(int capacity) {
        this.capacity = capacity;
        this.size = 0;
        head = new DLinkedNode(0, 0);
        tail = new DLinkedNode(0, 0);
        head.next = tail;
        tail.prev = head;
    }

    public int get(int key) {
        DLinkedNode node = cache.get(key);
        if (node == null) return -1;
        moveToHead(node);
        return node.value;
    }

    public void put(int key, int value) {
        DLinkedNode node = cache.get(key);
        if (node != null) {
            node.value = value;
            moveToHead(node);
        } else {
            DLinkedNode newNode = new DLinkedNode(key, value);
            cache.put(key, newNode);
            addToHead(newNode);
            size++;
            if (size > capacity) {
                DLinkedNode removed = removeTail();
                cache.remove(removed.key);
                size--;
            }
        }
    }
    // 省略双向链表操作方法：addToHead, removeNode, moveToHead, removeTail
}

复杂度：所有操作 O(1)，空间 O(capacity)。

十四题对比与总结

题目	技巧分类	时间复杂度	空间复杂度	核心要点
206 反转链表	基础反转	O(n)	O(1)	三指针迭代
234 回文链表	反转 + 快慢指针	O(n)	O(1)	找中点，反转后半
24 两两交换	交换操作	O(n)	O(1)	虚拟头，三指针
25 K 组翻转	递归/迭代反转	O(n)	O(1)/O(k)	先判长度，再反转区间
141 环检测	快慢指针	O(n)	O(1)	同步移动检测相遇
142 环入口	快慢指针	O(n)	O(1)	相遇后重置步调
160 相交链表	双指针	O(m+n)	O(1)	互换路径长度
19 删除倒数 N	快慢指针	O(n)	O(1)	虚拟头，先走 N+1
21 合并两链表	归并	O(m+n)	O(1)	虚拟头，逐次选择
2 两数相加	模拟加法	O(n)	O(n)	进位处理
23 合并 K 链表	优先队列/分治	O(N log K)	O(K)	堆维护当前最小
138 随机复制	原地复制	O(n)	O(1)	三步法：插、改、拆
148 排序链表	归并排序（迭代）	O(n log n)	O(1)	自底向上合并
146 LRU	哈希表+双向链表	O(1)	O(capacity)	双向链表移动节点

总结心法：

遇到链表题，优先考虑是否需要虚拟头结点（dummy）。
涉及位置或距离，尝试快慢指针或双指针。
需要反转或重组，考虑迭代三指针或递归。
需要随机访问或快速查找，可借助哈希表。
排序等复杂操作，归并排序是链表天然适合的算法。

滑动窗口模块 — LeetCode 热门 100 题精讲（Java 向）

Sun, 19 Jul 2026 00:00:00 +0000

滑动窗口思想概述

滑动窗口是双指针的一种特殊形态，专治 子串（子数组）相关的最优/判定问题。它维护一个左右指针（left 和 right）定义的窗口区间，通过不断移动右指针扩大窗口、移动左指针缩小窗口，在单次线性扫描中探索所有可能的可行解，从而避免暴力枚举所有子串的 O(n²) 开销。

滑动窗口的核心在于 窗口内数据状态的动态维护，通常借助哈希表或数组计数器记录窗口内元素的频次、种类、和等指标。当窗口满足某个条件时，尝试收缩左边界以寻找更优解，否则扩张右边界以包含更多元素。

LeetCode 热门 100 题中，有三道题是滑动窗口的经典代表：3. 无重复字符的最长子串（求最长满足条件的子串）、438. 找到字符串中所有字母异位词（求所有满足条件的子串起始位置）、76. 最小覆盖子串（求最短满足条件的子串）。它们覆盖了滑动窗口的三种主要题型：最长、所有、最短，掌握这三题即可应对绝大多数场景。

1. 无重复字符的最长子串（LeetCode 3）

题目：给定一个字符串 s，找出其中不含有重复字符的 最长子串 的长度。

暴力法：枚举所有子串，用哈希集合检查是否有重复字符，时间复杂度 O(n²)。

滑动窗口思路：

用右指针 right 遍历字符串，将字符逐个加入窗口。
用哈希集合（或数组计数）记录窗口内出现过的字符。
当遇到重复字符时，左指针 left 不断右移，并从集合中移除移出字符，直到窗口中不再有重复字符。
每次调整后，用当前窗口长度 right - left + 1 更新最大值。

public int lengthOfLongestSubstring(String s) {
    Set<Character> set = new HashSet<>();
    int left = 0, maxLen = 0;
    for (int right = 0; right < s.length(); right++) {
        char c = s.charAt(right);
        while (set.contains(c)) {
            set.remove(s.charAt(left));
            left++;
        }
        set.add(c);
        maxLen = Math.max(maxLen, right - left + 1);
    }
    return maxLen;
}

复杂度：O(n)，每个字符最多被加入和移出各一次，空间 O(min(m, n))（m 为字符集大小）。

关键点：while 循环处理重复，确保窗口内始终无重复字符；更新最大长度的时机在调整完成后。

2. 找到字符串中所有字母异位词（LeetCode 438）

题目：给定字符串 s 和 p，找到 s 中所有 p 的异位词的起始索引。异位词指字母种类和数量相同，顺序不限。

暴力法：枚举 s 中所有长度为 len(p) 的子串，统计字母频次比较，O(n * m)。

滑动窗口思路：窗口固定为 p.length() 大小，用右指针 right 移动，同时维护一个计数器数组记录窗口内各字母频次。当窗口长度正好等于 p.length() 时，比较窗口频次数组与 p 的频次数组是否相等，若相等则记录左指针。每次右移后，将新字符加入频次，并移除左指针指向的旧字符（保持窗口长度固定）。

public List<Integer> findAnagrams(String s, String p) {
    List<Integer> res = new ArrayList<>();
    if (s.length() < p.length()) return res;
    int[] pCount = new int[26];
    int[] winCount = new int[26];
    for (char c : p.toCharArray()) pCount[c - 'a']++;
    int left = 0;
    for (int right = 0; right < s.length(); right++) {
        winCount[s.charAt(right) - 'a']++;
        if (right - left + 1 > p.length()) {
            winCount[s.charAt(left) - 'a']--;
            left++;
        }
        if (right - left + 1 == p.length() && Arrays.equals(winCount, pCount)) {
            res.add(left);
        }
    }
    return res;
}

复杂度：O(n * 26) = O(n)，空间 O(1)（固定 26 长度）。

关键点：窗口长度固定，每次移动右指针后，若长度超出则移动左指针，保证窗口长度恰好为 m；比较频次数组可直接用 Arrays.equals。

3. 最小覆盖子串（LeetCode 76）

题目：给定字符串 s 和 t，在 s 中找到包含 t 中所有字符（包括重复字符）的 最短子串，若不存在返回空串。

难点：窗口需要动态伸缩，既要包含所有所需字符，又要尽量短。

滑动窗口思路：用哈希表 need 记录 t 中每个字符的需求数量，用 window 记录当前窗口内各字符出现次数。用 formed 记录当前窗口中满足需求（频次 >= need）的字符种类数，当 formed == need.size() 时，窗口已覆盖所有所需字符。此时尝试收缩左指针以缩小窗口，并不断更新最小长度和起始位置；收缩时若某个字符频次不满足需求，则 formed 减少。继续移动右指针扩大窗口。

public String minWindow(String s, String t) {
    Map<Character, Integer> need = new HashMap<>();
    Map<Character, Integer> window = new HashMap<>();
    for (char c : t.toCharArray()) {
        need.put(c, need.getOrDefault(c, 0) + 1);
    }
    int left = 0, right = 0;
    int formed = 0, required = need.size();
    int minLen = Integer.MAX_VALUE, start = 0;

    while (right < s.length()) {
        char c = s.charAt(right);
        window.put(c, window.getOrDefault(c, 0) + 1);
        if (need.containsKey(c) && window.get(c).intValue() == need.get(c).intValue()) {
            formed++;
        }
        while (left <= right && formed == required) {
            c = s.charAt(left);
            if (right - left + 1 < minLen) {
                minLen = right - left + 1;
                start = left;
            }
            window.put(c, window.get(c) - 1);
            if (need.containsKey(c) && window.get(c).intValue() < need.get(c).intValue()) {
                formed--;
            }
            left++;
        }
        right++;
    }
    return minLen == Integer.MAX_VALUE ? "" : s.substring(start, start + minLen);
}

复杂度：O(n + m)，空间 O(k)（k 为字符集大小）。

关键点：formed 记录的是字符种类数（去重），只有当某个字符的窗口频次 恰好等于 需求频次时才增加，减少时机类似；收缩时先更新最小长度，再移出左字符，最后调整 formed。

三题对比与启发

题目	窗口大小	目标	收缩条件	记录时机	时间复杂度
无重复字符最长	动态（尽量大）	求最大长度	窗口内出现重复	每次调整后	O(n)
字母异位词	固定 (len p)	求所有起始位置	窗口大小 > len p	窗口大小 == len p 且频次匹配	O(n)
最小覆盖子串	动态（尽量小）	求最小长度	窗口满足覆盖	满足覆盖时	O(n)

共同本质：滑动窗口利用双指针同步移动，在右指针扩张、左指针收缩的过程中，只关注当前窗口的有效信息，通过状态变量（如计数、formed）避免每次重新统计窗口，将 O(n²) 的暴力枚举降为 O(n)。

不同侧重：

无重复字符：以"无重复"为约束，遇到冲突即收缩。
字母异位词：固定窗口长度，滑动比较频次。
最小覆盖子串：以"包含所有所需字符"为约束，满足后不断收缩找最短。

总结：滑动窗口模块的核心心法

滑动窗口的精髓在于用两个指针维护一个动态区间，并利用计数器或哈希表 O(1) 维护区间状态。所有题目都遵循"右指针扩大窗口找可行解，左指针缩小窗口优化解"的通用框架。

应用滑动窗口的通用模板：

定义窗口状态变量（计数器、频次数组、满足条件计数等）。
右指针 right 逐位移动，更新状态。
当窗口满足题目条件时（或触发收缩条件时），进入 while 循环，移动左指针 left 缩小窗口，同时更新答案（长度、起始位置等）。
在收缩过程中，同步更新窗口状态，直到条件不再满足。

掌握这三题，就能识别大多数滑动窗口变种（如固定窗口、可变窗口、求最值、求所有解）。面试中遇到子串相关题目，优先思考能否用滑动窗口 O(n) 解决。

普通数组模块 — LeetCode 热门 100 题精讲（Java 向）

Sun, 19 Jul 2026 00:00:00 +0000

普通数组问题概述

数组是算法题中最基础也最灵活的数据结构。所谓"普通数组"，指不涉及树、图等复杂结构，纯粹在数组上进行操作，其解题技巧往往依赖于观察规律和巧妙的空间复用。

LeetCode 热门 100 题中，有五道经典题覆盖了数组操作的五个不同维度：

53. 最大子数组和 — 贪心 / DP 的简洁应用（Kadane 算法）。
56. 合并区间 — 排序后线性扫描，典型区间合并模板。
189. 轮转数组 — 原地翻转技巧，空间 O(1) 的反转三趟。
238. 除自身以外数组的乘积 — 前后缀积，避免除法。
41. 缺失的第一个正数 — 原地哈希，利用数组下标作桶。

它们各自代表了数组问题中一类常见的优化思路。下面逐一拆解。

1. 最大子数组和（LeetCode 53）

题目：给定整数数组 nums，找出一个具有最大和的连续子数组（至少包含一个元素），返回其最大和。

暴力法：枚举所有子数组，计算和，O(n²)。

优化思路（Kadane 算法）：遍历数组，维护两个变量：currentSum 表示以当前元素结尾的子数组最大和，maxSum 记录全局最大和。递推公式为：

currentSum = max(nums[i], currentSum + nums[i])
maxSum = max(maxSum, currentSum)

即要么从当前元素重新开始，要么将当前元素追加到之前的子数组上。这本质是贪心或一维动态规划。

public int maxSubArray(int[] nums) {
    int currentSum = nums[0];
    int maxSum = nums[0];
    for (int i = 1; i < nums.length; i++) {
        currentSum = Math.max(nums[i], currentSum + nums[i]);
        maxSum = Math.max(maxSum, currentSum);
    }
    return maxSum;
}

复杂度：时间 O(n)，空间 O(1)。

关键点：当 currentSum 为负数时，舍弃之前的部分，从当前元素重新开始会更优。

2. 合并区间（LeetCode 56）

题目：给出一个区间的集合，合并所有重叠的区间。

优化思路（排序 + 线性扫描）：先将区间按左端点升序排序。然后遍历区间，若当前区间的左端点 <= 上一个合并区间右端点，则合并（更新右端点为较大值）；否则，将上一个合并区间加入结果，开始新合并区间。

public int[][] merge(int[][] intervals) {
    if (intervals.length <= 1) return intervals;
    Arrays.sort(intervals, (a, b) -> a[0] - b[0]);
    List<int[]> merged = new ArrayList<>();
    int[] current = intervals[0];
    for (int i = 1; i < intervals.length; i++) {
        if (intervals[i][0] <= current[1]) {
            current[1] = Math.max(current[1], intervals[i][1]);
        } else {
            merged.add(current);
            current = intervals[i];
        }
    }
    merged.add(current);
    return merged.toArray(new int[merged.size()][]);
}

复杂度：排序 O(n log n)，扫描 O(n)，总时间 O(n log n)，空间 O(log n) 用于排序。

关键点：排序后只需要一次遍历；合并时右端点取两者最大值。

3. 轮转数组（LeetCode 189）

题目：将数组中的元素向右轮转 k 个位置。要求空间 O(1) 原地操作。

优化思路（三趟翻转）：

先对整个数组翻转。
再对前 k 个元素翻转（k = k % n）。
最后对剩余元素翻转。

public void rotate(int[] nums, int k) {
    int n = nums.length;
    k %= n;
    reverse(nums, 0, n - 1);
    reverse(nums, 0, k - 1);
    reverse(nums, k, n - 1);
}
private void reverse(int[] nums, int left, int right) {
    while (left < right) {
        int temp = nums[left];
        nums[left] = nums[right];
        nums[right] = temp;
        left++;
        right--;
    }
}

复杂度：时间 O(n)，空间 O(1)。

关键点：k %= n 处理 k 大于数组长度的情况；翻转顺序不能颠倒。

4. 除自身以外数组的乘积（LeetCode 238）

题目：返回数组 answer，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。要求不用除法，O(n) 时间。

优化思路（前后缀乘积）：先用 answer 数组存储左侧乘积，然后从右往左乘以右侧乘积，滚动更新右侧乘积变量。

public int[] productExceptSelf(int[] nums) {
    int n = nums.length;
    int[] ans = new int[n];
    ans[0] = 1;
    for (int i = 1; i < n; i++) {
        ans[i] = ans[i-1] * nums[i-1];
    }
    int rightProduct = 1;
    for (int i = n - 1; i >= 0; i--) {
        ans[i] = ans[i] * rightProduct;
        rightProduct *= nums[i];
    }
    return ans;
}

复杂度：时间 O(n)，空间 O(1)（除返回数组外）。

5. 缺失的第一个正数（LeetCode 41）

题目：找出未排序整数数组中没有出现的最小正整数。要求 O(n) 时间，O(1) 空间。

优化思路（原地哈希）：将数组视为哈希表，下标 i 对应数值 i+1。遍历数组，将每个数放到它应该在的位置（即 nums[i] 应该在 nums[nums[i]-1] 处），交换直到当前位置的值是正确值或越界。然后再遍历一次，第一个 nums[i] != i+1 的位置就是缺失的最小正数。

public int firstMissingPositive(int[] nums) {
    int n = nums.length;
    for (int i = 0; i < n; i++) {
        while (nums[i] >= 1 && nums[i] <= n && nums[nums[i] - 1] != nums[i]) {
            int temp = nums[nums[i] - 1];
            nums[nums[i] - 1] = nums[i];
            nums[i] = temp;
        }
    }
    for (int i = 0; i < n; i++) {
        if (nums[i] != i + 1) {
            return i + 1;
        }
    }
    return n + 1;
}

复杂度：时间 O(n)（每个元素最多交换两次），空间 O(1)。

五题对比与启发

题目	核心技巧	时间复杂度	空间复杂度	关键特征
最大子数组和	Kadane 贪心/DP	O(n)	O(1)	递推当前最优，舍弃负数前缀
合并区间	排序 + 线性扫描	O(n log n)	O(log n)	按左端点排序，合并重叠
轮转数组	三次翻转	O(n)	O(1)	利用翻转交换前后块
除自身以外乘积	前后缀积	O(n)	O(1)	两次遍历，右侧乘积滚动
缺失第一个正数	原地哈希	O(n)	O(1)	利用下标做桶，交换归位

总结心法：

如果涉及子数组最值 → 考虑 Kadane 或 DP。
如果涉及区间合并 → 排序后线性扫描。
如果涉及循环移位 → 考虑翻转或取模映射。
如果涉及所有元素乘积（不含自身） → 用前后缀积空间优化。
如果涉及最小缺失正数 → 用原地哈希，通过交换把数放回"正确位置"。

子串与子数组模块 — LeetCode 热门 100 题精讲（Java 向）

Sun, 19 Jul 2026 00:00:00 +0000

子串与子数组问题概述

子串（字符串连续片段）与子数组（数组连续片段）在算法题中占据半壁江山。解决此类问题的优化思路通常围绕"消除重复计算"展开，常见工具包括：

前缀和 + 哈希表：将区间和转化为两前缀和之差，O(1) 查询目标值，典型题如和为 K 的子数组。
单调队列：维护窗口内的极值，在滑动过程中 O(1) 获取最大值/最小值，典型题如滑动窗口最大值。
双指针滑动窗口：动态伸缩窗口，配合状态变量（频次计数）在 O(n) 内求解最短/最长覆盖子串，典型题如最小覆盖子串。

LeetCode 热门 100 题中，有三道题分别代表了上述三种范式的经典应用：560. 和为 K 的子数组（前缀和+哈希）、239. 滑动窗口最大值（单调队列）、76. 最小覆盖子串（滑动窗口+频次计数）。下面逐一拆解。

1. 和为 K 的子数组（LeetCode 560）

题目：给定整数数组 nums 和整数 k，统计连续子数组之和等于 k 的个数。

暴力法：枚举所有子数组 (i, j)，累加求和并计数，时间复杂度 O(n²)。

优化思路（前缀和 + 哈希表）：设前缀和 pre[i] = nums[0] + ... + nums[i]，则子数组 (j, i] 的和 = pre[i] - pre[j-1]。要使其等于 k，等价于 pre[j-1] = pre[i] - k。因此，在遍历 i 时，只需查找之前出现过多少个前缀和等于 pre[i] - k，累加计数。用哈希表存储前缀和出现次数，初始放入 {0: 1} 代表空前缀。

public int subarraySum(int[] nums, int k) {
    Map<Integer, Integer> prefixCount = new HashMap<>();
    prefixCount.put(0, 1);
    int sum = 0, count = 0;
    for (int num : nums) {
        sum += num;
        count += prefixCount.getOrDefault(sum - k, 0);
        prefixCount.put(sum, prefixCount.getOrDefault(sum, 0) + 1);
    }
    return count;
}

复杂度：时间 O(n)，空间 O(n)。

关键点：先查 target 再更新当前前缀和，避免 k=0 时将自身计入；哈希表存储频次而非布尔值，因为可能存在多个相同前缀和。

2. 滑动窗口最大值（LeetCode 239）

题目：给定数组 nums 和窗口大小 k，从左向右滑动窗口，返回每个窗口中的最大值。

暴力法：每个窗口扫描 k 个元素求最大值，总时间复杂度 O(n·k)。

优化思路（单调队列）：维护一个双端队列（Deque），其中存储数组下标，且队列中下标对应的元素值 严格单调递减。这样队首始终是当前窗口最大值的下标。窗口滑动时：

移除队首出界的下标（index < i-k+1）。
从队尾移除所有小于当前元素值的下标（因为它们不可能成为后续窗口的最大值）。
将当前下标加入队尾。
若窗口已形成（i >= k-1），队首即为当前窗口最大值。

public int[] maxSlidingWindow(int[] nums, int k) {
    if (nums.length == 0 || k == 0) return new int[0];
    int n = nums.length;
    int[] result = new int[n - k + 1];
    Deque<Integer> deque = new ArrayDeque<>();
    for (int i = 0; i < n; i++) {
        while (!deque.isEmpty() && deque.peekFirst() < i - k + 1) {
            deque.pollFirst();
        }
        while (!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
            deque.pollLast();
        }
        deque.offerLast(i);
        if (i >= k - 1) {
            result[i - k + 1] = nums[deque.peekFirst()];
        }
    }
    return result;
}

复杂度：每个元素入队出队各一次，时间 O(n)，空间 O(k)。

关键点：队列存储下标便于判断是否出界；单调性确保队首始终最大；新元素从队尾踢掉所有比自己小的元素。

3. 最小覆盖子串（LeetCode 76）

题目：给定字符串 s 和 t，在 s 中找到包含 t 中所有字符（含重复次数）的最短子串，若不存在返回空串。

优化思路（滑动窗口 + 频次计数器）：

用 need 哈希表记录 t 中每个字符的需求量，用 window 记录当前窗口内各字符出现次数。
用 formed 记录当前窗口内满足需求（频次 >= need）的 字符种类数，当 formed == need.size() 时窗口已经覆盖所有字符。
右指针 right 不断右移，加入新字符并更新 window 和 formed。
当 formed == required 时，尝试收缩左指针 left，在收缩过程中不断更新最小长度和起始位置，同时更新 window 和 formed，直到不再满足条件。

public String minWindow(String s, String t) {
    Map<Character, Integer> need = new HashMap<>();
    Map<Character, Integer> window = new HashMap<>();
    for (char c : t.toCharArray()) {
        need.put(c, need.getOrDefault(c, 0) + 1);
    }
    int left = 0, right = 0;
    int formed = 0, required = need.size();
    int minLen = Integer.MAX_VALUE, start = 0;

    while (right < s.length()) {
        char c = s.charAt(right);
        window.put(c, window.getOrDefault(c, 0) + 1);
        if (need.containsKey(c) && window.get(c).intValue() == need.get(c).intValue()) {
            formed++;
        }
        while (left <= right && formed == required) {
            c = s.charAt(left);
            if (right - left + 1 < minLen) {
                minLen = right - left + 1;
                start = left;
            }
            window.put(c, window.get(c) - 1);
            if (need.containsKey(c) && window.get(c).intValue() < need.get(c).intValue()) {
                formed--;
            }
            left++;
        }
        right++;
    }
    return minLen == Integer.MAX_VALUE ? "" : s.substring(start, start + minLen);
}

复杂度：时间 O(n + m)，空间 O(k)（k 为字符集大小）。

关键点：formed 记录的是种类数（去重），只有当某个字符的窗口频次 恰好等于 需求频次时才加一，减一同样在恰好小于时发生；收缩时要先更新答案再移出左字符。

三题对比与启发

题目	核心技巧	数据结构	时间复杂度	空间复杂度	典型特征
和为 K 的子数组	前缀和 + 哈希表	HashMap	O(n)	O(n)	统计区间和等于目标值的数量
滑动窗口最大值	单调队列	Deque	O(n)	O(k)	维护固定窗口内最值
最小覆盖子串	双指针滑动窗口 + 频次计数	HashMap + 双指针	O(n)	O(k)	求最短覆盖子串

共同本质：三者都利用了某种 “增量维护” 的思想，在遍历过程中实时更新状态，避免重复计算。前缀和哈希将区间和查询变为差值查询；单调队列在 O(1) 内获取窗口最值；滑动窗口通过双指针和频次计数器动态伸缩。

不同侧重：

560：依赖累积和的线性关系，配合哈希表快速查找目标值。
239：借助单调性剔除不可能成为答案的元素，保持队列有序。
76：利用双指针伸缩窗口，并在满足条件时收缩以寻找最优解。

总结：子串与子数组模块的核心心法

子串/子数组问题的优化核心在于"复用历史信息"。无论是前缀和的累加结果、单调队列维护的极值，还是滑动窗口内的频次状态，都避免了每次重新扫描整个区间。

解题时的思考路径：

若问题涉及 区间求和 或计数，优先考虑前缀和 + 哈希表。

若问题涉及 固定窗口的最值，使用单调队列。

若问题涉及 动态窗口的最优覆盖或约束，使用双指针滑动窗口，配合状态变量。

若上述均不适用，再考虑其他复杂方法（如 DP、分治等）。

掌握这三道题，你就掌握了数组/字符串子区间问题中最常用的三种优化利器。

LeetCode 热门 100 题之双指针模块精讲（Java 向）

Sat, 18 Jul 2026 00:00:00 +0000

概述

双指针（Two Pointers）是数组与链表类问题中最基础也最强大的算法技巧之一。其核心思想是利用两个指针（通常是索引）以某种策略遍历数据结构，从而将原本需要嵌套循环的 O(n²) 甚至 O(n³) 的暴力解法，优化为 O(n) 的单次遍历。

双指针主要分为两类场景：

左右指针（相向指针）：两个指针分别从数组的两端向中间移动，常用于处理「有序数组中的配对问题」或「区间最值问题」。典型代表是盛最多水的容器和三数之和。
快慢指针（同向指针）：两个指针从同一侧出发，移动速度不同，常用于原地去重、移除元素等。典型代表是移动零。

双指针最大的优势在于时间复杂度低（通常 O(n)）且空间复杂度为 O(1)，不需要额外的数据结构存储中间结果。本文选取 LeetCode 热门 100 题中双指针模块的 4 道经典题目，从暴力解法的缺陷出发，逐步推导双指针的优化思路，并给出完整的 Java 实现。

题目一：283. 移动零

题目简述

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

示例：输入 [0,1,0,3,12]，输出 [1,3,12,0,0]

要求：必须原地修改数组，不能复制额外的数组。

暴力解法

最直观的思路是新建一个数组，遍历原数组将非零元素按顺序放入新数组，最后在末尾补零。但这样做空间复杂度为 O(n)，不符合「原地修改」的要求。

另一种暴力思路是每次遇到零，就将后面的所有元素前移一位，时间复杂度为 O(n²)，效率极低。

优化思路：快慢双指针（同向指针）

核心思想：使用两个指针，一个慢指针指向下一个非零元素应该放置的位置，一个快指针用于遍历数组。

快指针 r 负责扫描整个数组。
慢指针 l 始终指向「已处理区域的下一个位置」，即下一个非零元素应该存放的位置。

每当快指针遇到非零元素，就将其与慢指针指向的位置交换（或赋值），然后慢指针前进一位。遍历结束后，所有非零元素都在数组前端，剩余位置自然全是零。

具体实现步骤

初始化慢指针 l = 0。
快指针 r 从 0 遍历到 n-1：
- 若 nums[r] != 0，将 nums[r] 与 nums[l] 交换，l++。
遍历结束，数组前 l 个位置均为非零元素且保持相对顺序，l 之后均为零。

class Solution {
    public void moveZeroes(int[] nums) {
        int l = 0; // 慢指针：指向下一个非零元素应该放置的位置
        for (int r = 0; r < nums.length; r++) {
            if (nums[r] != 0) {
                // 交换非零元素到前面
                if (l != r) {
                    int temp = nums[l];
                    nums[l] = nums[r];
                    nums[r] = temp;
                }
                l++;
            }
        }
    }
}

复杂度分析

维度	复杂度
时间复杂度	O(n)，仅需一次遍历
空间复杂度	O(1)，仅使用常数额外空间

关键点与易错点

相对顺序的保持：由于慢指针只在遇到非零元素时才前进，且交换操作不改变非零元素之间的相对顺序，因此天然满足题目要求。
原地修改：所有操作都在原数组上进行，没有创建新数组。
交换 vs 赋值：也可以采用「赋值 + 补零」的方式——先将非零元素依次赋值到前面，遍历结束后将剩余位置全部置零。两种方式均可，交换法更简洁。

题目二：11. 盛最多水的容器

题目简述

给定一个长度为 n 的整数数组 height，有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i])。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

示例：输入 height = [1,8,6,2,5,4,8,3,7]，输出 49

说明：不能倾斜容器。

暴力解法

遍历所有可能的 (i, j) 组合，计算 min(height[i], height[j]) * (j - i)，记录最大值。

时间复杂度为 O(n²)，当 n 较大时（题目中 n 可达 10⁵）会超时。

优化思路：左右双指针（相向指针）

核心洞察：水的高度由较矮的那条线决定（木桶短板效应）。

初始化左指针 left = 0，右指针 right = n - 1，此时宽度最大。
每次计算当前容器容量，更新最大值。
关键贪心策略：永远移动较矮的那一侧指针。
- 如果移动较高的一侧，宽度减小，高度不可能增加（因为高度由较矮的一侧决定），容量只会更小。
- 移动较矮的一侧，才有机会遇到更高的柱子，从而增大容量。

具体实现步骤

初始化 left = 0，right = height.length - 1，max = 0。
当 left < right 时循环：
- 计算当前容量：min(height[left], height[right]) * (right - left)。
- 更新 max。
- 若 height[left] < height[right]，则 left++；否则 right--。
返回 max。

class Solution {
    public int maxArea(int[] height) {
        int left = 0;
        int right = height.length - 1;
        int max = 0;
        while (left < right) {
            int h = Math.min(height[left], height[right]);
            int w = right - left;
            max = Math.max(max, h * w);
            if (height[left] < height[right]) {
                left++;
            } else {
                right--;
            }
        }
        return max;
    }
}

复杂度分析

维度	复杂度
时间复杂度	O(n)，每个元素最多被访问一次
空间复杂度	O(1)，仅使用常数额外空间

关键点与易错点

为什么移动短板而非长板：这是本题最核心的直觉。容量 = 短板高度 × 宽度。移动长板时，短板高度不变（或变小），宽度减小，容量必减。只有移动短板，短板高度才有可能提升。
指针相遇即停止：当 left >= right 时，所有可能的容器都已考察完毕。
与接雨水的区别：盛最多水的容器是选两条线求最大容量；接雨水是利用所有柱子计算总积水量。两者虽都用到左右双指针，但逻辑截然不同。

题目三：15. 三数之和

题目简述

给定一个整数数组 nums，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k、j != k，且 nums[i] + nums[j] + nums[k] == 0。返回所有和为 0 且不重复的三元组。

示例：输入 nums = [-1,0,1,2,-1,-4]，输出 [[-1,-1,2],[-1,0,1]]

注意：答案中不可以包含重复的三元组。

暴力解法

三重循环枚举所有三元组，时间复杂度 O(n³)，且去重非常麻烦。

优化思路：排序 + 双指针

核心思想：先排序，再固定一个数，将问题转化为「两数之和」。

排序后数组有序，可以利用双指针从两端向中间逼近。
固定第一个数 nums[i]，然后在 i+1 到 n-1 的范围内用双指针寻找两个数，使得三数之和为 0。
排序带来的另一个好处是方便去重：跳过相邻的重复元素。

具体实现步骤

对数组进行排序。
外层循环 i 从 0 到 n-3：
- 剪枝：若 nums[i] > 0，由于数组已排序，后续所有数都 >= nums[i] > 0，三数之和必 > 0，直接 break。
- 去重：若 i > 0 且 nums[i] == nums[i-1]，跳过当前 i，避免重复三元组。
- 初始化左指针 l = i + 1，右指针 r = n - 1。
- 当 l < r 时循环：
  - 计算 sum = nums[i] + nums[l] + nums[r]。
  - 若 sum == 0：找到一组解，加入结果集；然后移动 l 和 r 并跳过所有重复值。
  - 若 sum < 0：和太小，l++。
  - 若 sum > 0：和太大，r--。
返回结果集。

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> ans = new ArrayList<>();
        if (nums == null || nums.length < 3) return ans;

        Arrays.sort(nums);
        int n = nums.length;

        for (int i = 0; i < n - 2; i++) {
            // 剪枝：最小值已大于0，不可能有解
            if (nums[i] > 0) break;
            // 去重：跳过重复的起始值
            if (i > 0 && nums[i] == nums[i - 1]) continue;

            int l = i + 1, r = n - 1;
            while (l < r) {
                int sum = nums[i] + nums[l] + nums[r];
                if (sum == 0) {
                    ans.add(Arrays.asList(nums[i], nums[l], nums[r]));
                    // 跳过重复的左值
                    while (l < r && nums[l] == nums[l + 1]) l++;
                    // 跳过重复的右值
                    while (l < r && nums[r] == nums[r - 1]) r--;
                    l++;
                    r--;
                } else if (sum < 0) {
                    l++;
                } else {
                    r--;
                }
            }
        }
        return ans;
    }
}

复杂度分析

维度	复杂度
时间复杂度	O(n²)：排序 O(n log n)，外层循环 O(n)，内层双指针 O(n)，整体 O(n²)
空间复杂度	O(log n) 到 O(n)：排序所需栈空间（取决于排序算法），不计输出空间时为 O(1)

关键点与易错点

排序是前提：双指针在有序数组上才能根据 sum 与 0 的大小关系决定指针移动方向。
去重是难点：需要在外层循环和找到解后两处进行去重。
- 外层：if (i > 0 && nums[i] == nums[i-1]) continue;
- 内层找到解后：while (l < r && nums[l] == nums[l+1]) l++; 和 while (l < r && nums[r] == nums[r-1]) r--;
剪枝优化：if (nums[i] > 0) break; 利用有序数组的特性提前终止。
指针更新：找到解后，在跳过重复值之后，必须执行 l++ 和 r--，否则会陷入死循环。

题目四：42. 接雨水

题目简述

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

示例：输入 height = [0,1,0,2,1,0,1,3,2,1,2,1]，输出 6

暴力解法

对于每个位置 i，分别向左和向右扫描找到左侧最高柱和右侧最高柱，该位置能接的雨水量为 min(leftMax, rightMax) - height[i]（若为正）。

时间复杂度 O(n²)，空间复杂度 O(1)。

优化思路：左右双指针（相向指针）

核心思想：利用两个指针从两端向中间移动，同时维护左侧最高和右侧最高的柱子高度。

对于位置 i 能否接水，取决于 min(左侧最高, 右侧最高) - height[i]。

双指针的精妙之处在于：我们不需要同时知道左右两侧的最高值，只需要知道当前指针所在一侧的最高值是否小于另一侧。

若 height[left] < height[right]，说明 left 位置的「天花板」由左侧最高决定（因为右侧有更高的柱子），此时可以安全地计算 left 位置的积水量。

具体实现步骤

初始化 left = 0，right = height.length - 1，leftMax = 0，rightMax = 0，water = 0。
当 left < right 时循环：
- 若 height[left] < height[right]：
  - 若 height[left] >= leftMax，更新 leftMax = height[left]。
  - 否则，water += leftMax - height[left]。
  - left++。
- 否则（height[left] >= height[right]）：
  - 若 height[right] >= rightMax，更新 rightMax = height[right]。
  - 否则，water += rightMax - height[right]。
  - right--。
返回 water。

class Solution {
    public int trap(int[] height) {
        int left = 0;
        int right = height.length - 1;
        int leftMax = 0;
        int rightMax = 0;
        int water = 0;

        while (left < right) {
            if (height[left] < height[right]) {
                if (height[left] >= leftMax) {
                    leftMax = height[left];
                } else {
                    water += leftMax - height[left];
                }
                left++;
            } else {
                if (height[right] >= rightMax) {
                    rightMax = height[right];
                } else {
                    water += rightMax - height[right];
                }
                right--;
            }
        }
        return water;
    }
}

复杂度分析

维度	复杂度
时间复杂度	O(n)，每个元素最多被访问一次
空间复杂度	O(1)，仅使用常数额外空间

关键点与易错点

为什么 height[left] < height[right] 时能安全计算左侧：因为此时 right 侧存在一个比 left 更高的柱子，所以 left 位置的右侧最高至少是 height[right]，而左侧最高已知为 leftMax。因此 left 位置的水位由 leftMax 决定，可以立即计算。
与「盛最多水的容器」的区别：两者都使用左右双指针从两端向中间移动，但移动条件和计算逻辑完全不同。
- 盛最多水：计算面积，移动较矮指针。
- 接雨水：计算积水量，根据两侧最高值决定移动哪一侧。
初始化边界：leftMax 和 rightMax 初始为 0，因为边界外没有柱子，高度为 0。
积水量的计算：只有当前高度 < 当前侧最高值时才有积水量，否则更新最高值。

总结：双指针模块对比与通用心法

四题对比一览

题目	双指针类型	核心技巧	是否排序	时间复杂度	空间复杂度
283. 移动零	快慢指针（同向）	慢指针指向非零元素放置位置	否	O(n)	O(1)
11. 盛最多水的容器	左右指针（相向）	移动较矮指针，贪心求最大面积	否	O(n)	O(1)
15. 三数之和	左右指针（相向）	排序 + 固定一个数 + 双指针找两数	是	O(n²)	O(log n) ~ O(n)
42. 接雨水	左右指针（相向）	维护左右最高，低侧先计算	否	O(n)	O(1)

双指针通用解题心法

识别题型：数组/链表问题，若暴力解法需要多层循环，优先考虑双指针能否优化。
确定指针类型：
- 同向指针（快慢指针）：适合原地修改、去重、移除元素等场景。
- 相向指针（左右指针）：适合有序数组配对、区间最值、面积/水量计算等场景。
排序是双刃剑：三数之和依赖排序才能使用双指针；但盛最多水和接雨水不需要排序，排序反而会破坏原始位置信息。
明确指针移动条件：双指针的核心是每次只移动一个指针，移动哪个取决于具体问题的逻辑。
- 移动零：快指针遍历，慢指针记录位置。
- 盛最多水：移动较矮的指针。
- 三数之和：根据 sum 与 0 的大小关系移动。
- 接雨水：根据两侧最高值决定移动哪一侧。
空间换时间的对立面：双指针的核心价值在于 O(1) 空间复杂度，在不使用额外数据结构的前提下将时间复杂度从 O(n²) 降至 O(n)。

掌握双指针的精髓，关键在于理解**「指针移动的单调性」**——即每次移动指针都能保证不会错过最优解。这四道题覆盖了双指针最典型的应用场景，吃透它们，足以应对绝大多数双指针类面试题。

哈希表模块 — LeetCode 热门 100 题精讲（Java 向）

Sat, 18 Jul 2026 00:00:00 +0000

引言：哈希 —— 算法世界的第一把加速器

在刷题初期，我们常被暴力解法的 O(n²) 甚至 O(n³) 折磨。而哈希表，往往是打破僵局的第一把钥匙。它不依靠复杂的逻辑推理，而是凭借 “记住已经见过的东西” 这种朴素思想，让查找从线性变为常数。

Java 中的 HashMap 和 HashSet 是哈希表的两种基本形态。前者存储键值对，后者只存键（本质上是值为常量的 HashMap）。它们平均时间复杂度均为 O(1)，代价是额外的内存开销。这正是 “空间换时间” 的典型体现。

LeetCode 热门 100 题中，有三道题是哈希表的"代言人"：第 1 题、第 49 题、第 128 题。它们分别展示了哈希在 配对查找、归类聚合、连续性判断 三个不同维度的应用。下面逐一拆解。

1. 两数之和（LeetCode 1）

题目：在无序数组中，找到两个数，使它们的和等于目标值，返回下标。

暴力法：双重循环枚举所有组合，O(n²)。当 n 很大时必然超时。

哈希优化思路：遍历数组时，对于当前数 nums[i]，我们只需要知道 之前是否出现过 target - nums[i]。如果出现过，就找到了答案。如果没有，就把当前数存入哈希表，供后续元素查找。

具体步骤：

初始化一个空 HashMap<Integer, Integer>，键为数值，值为下标。
从左到右遍历数组，对每个元素 x：
- 计算 complement = target - x。
- 查询哈希表是否包含 complement。若包含，直接返回 {map.get(complement), i}。
- 若不包含，将 (x, i) 存入哈希表。

为什么高效？ 因为哈希表的查找和插入都是 O(1)，所以整体复杂度降为 O(n)。这个思路的本质是 “用空间记录历史，避免未来重复查找”。

易错点：不能先把所有元素存入哈希表再查找，因为这样可能匹配到同一个元素两次（例如 [3,3] target=6，如果先存再找，会返回 (0,0)）。边遍历边存，天然避免了这个问题。

2. 字母异位词分组（LeetCode 49）

题目：给定字符串数组，将字母异位词（由相同字母不同排列组成）分到同一组。

暴力法：两两比较每个字符串是否是异位词，复杂度 O(n² * L log L)，不可接受。

哈希优化思路：异位词的本质是 字母构成完全相同。那么，我们可以找到一个 归一化标识，使得所有异位词的标识相同。最直接的方法就是排序：对字符串的字符数组排序，排序后的结果就是唯一标识。

具体步骤：

创建一个 HashMap<String, List<String>>，键为排序后的字符串，值为异位词列表。
遍历所有字符串 s：
- 将 s 转换为字符数组，排序，再转回字符串 key。
- 若哈希表中不存在 key，新建一个 ArrayList 放入。
- 将 s 添加到该 key 对应的列表中。
最后返回哈希表的所有 value 组成的列表。

为什么高效？ 每个字符串只需一次排序（O(L log L)）和一次哈希操作，总体时间复杂度为 O(n * L log L)，远优于两两比较。

进一步优化：如果字符串长度很长，排序开销变大，可以用 字母计数 作为键：统计每个字符出现次数，拼接成 "a3b1c2" 这种形式。但排序在 Java 中更简洁，且实际题量下足够。

关键点：哈希表在这里充当了 “分类器”，将具有相同特征（排序后相等）的元素聚合到一起，避免了嵌套循环的碰撞判断。

3. 最长连续序列（LeetCode 128）

题目：给定未排序的整数数组，找出最长的连续数字序列（如 [100,4,200,1,3,2] 中最长连续序列为 [1,2,3,4]，长度为 4）。

暴力法：排序后遍历，复杂度 O(n log n)，但题目要求 O(n)，所以排序不可取。

哈希优化思路：我们只需要 从每个连续序列的起点开始 计数。如何判断一个数是否是起点？—— 如果 num - 1 不在数组中，则 num 就是起点。这样，我们只需对每个起点向后查找 num+1, num+2...，直到断掉。

具体步骤：

将所有数存入 HashSet<Integer>，去重并支持 O(1) 查找。
遍历集合中的每个数 num：
- 如果 set.contains(num - 1)，说明 num 不是起点，直接跳过（因为它的序列会被起点统计）。
- 否则，从 num 开始，用 while (set.contains(current)) 递增计数，记录长度。
- 更新全局最大长度。

为什么高效？ 每个数最多被访问两次：一次作为起点被扫描序列，一次被跳过（作为非起点）。所以总复杂度 O(n)。

易错点：必须遍历 HashSet 而不是原数组，避免重复处理相同数字。另外，在 while 循环中，每次 current++ 时，不必从集合中删除当前数，因为后面不会再遇到（即使遇到也会被跳过或已处理），但删除可以略微加速，不是必须。

三题对比与启发

题目	哈希结构	核心思想	时间复杂度
两数之和	`HashMap`	查找互补数，历史记录	`O(n)`
字母异位词分组	`HashMap<String, List>`	归一化标识，归类聚合	`O(n * L log L)`
最长连续序列	`HashSet`	判断起点，只从起点延伸	`O(n)`

共同本质：都是利用哈希表的 “存在性查询” 能力，将原本需要嵌套循环的匹配问题，转化为单次遍历中的即时判断。

不同侧重：

两数之和：查询的是 “补数是否存在”，属于一对一匹配。
字母异位词分组：查询的是 “是否存在相同的归一化键”，属于一对多归类。
最长连续序列：查询的是 “下一个数是否存在”，属于链式延伸。

总结：哈希模块的核心心法

哈希表是一种"记忆"工具。它让我们在遍历过程中，能够瞬间回想起之前见过的任何元素，从而避免重复扫描。

应用哈希表的通用步骤：

识别问题中是否存在 “查找” 或 “判断存在” 的需求。

确定键是什么（原始值、变换后的值、组合值）。

确定值是什么（下标、计数、列表、布尔标志）。

遍历数据，边处理边维护哈希表，利用实时信息决策。

掌握这三道经典题，你就掌握了哈希表在算法竞赛中的绝大多数应用场景。后续遇到类似"求和"、“分组”、“连续"等关键词，第一反应就应该想到哈希表。

扩展思考

如果两数之和要求返回所有不重复的组合，哈希表如何处理？—— 可以排序后使用双指针，或者哈希表记录频次。
如果字母异位词分组要求按出现顺序输出，如何保证顺序？—— 使用 LinkedHashMap 或单独维护顺序列表。
如果最长连续序列要求返回具体序列而不是长度，如何修改？—— 在 while 循环中收集元素即可。

哈希表并非万能，当键值规模极大或哈希冲突严重时，可能退化为 O(n) 甚至更差。但在面试和竞赛中，它始终是解决问题的首选利器之一。