MuxiaoWF‘s

Hot100 算法笔记

MuxiaoWF — Sun, 09 Aug 2026 00:00:00 GMT

LeetCode 算法笔记

通用思维套路总览

看到什么特征 → 用什么算法

题目特征	首选算法	典型题目
有序数组 + 查找	二分查找	33, 34, 35, 74, 153
求「连续子数组」最值	滑动窗口 / 前缀和	3, 53, 209, 239
两个有序结构合并	双指针	11, 88, 167
O(n) 查找 / 去重 / 分组	哈希表	1, 49, 128, 560
链表找中点 / 环 / 倒数第 N	快慢指针	19, 141, 142, 876
树的遍历 / 层序	DFS 递归 / BFS 队列	94, 102, 104, 199
括号匹配 / 表达式求值	栈	20, 32, 394, 735
「下一个更大/更小」	单调栈	84, 739, 239
求所有方案 / 组合 / 排列	回溯	17, 22, 39, 46, 51, 78
最优解 + 子问题重叠	动态规划	53, 62, 70, 72, 198, 300
每步取局部最优 → 全局最优	贪心	11, 45, 55, 121, 135
Top K / 中位数	堆	23, 215, 295, 347
二维网格搜索 / 连通分量	BFS / DFS	200, 207, 547, 994
字符串前缀匹配	Trie	208
区间合并 / 插入	排序 + 遍历	56, 763

DP 识别套路

关键词	DP 类型	状态定义
最长 / 最短 / 最少 / 最多	优化型 DP	dp[i] = 前 i 个元素的最优值
能否 / 是否	可行性 DP	dp[i] = 前 i 个元素是否可行
方案数	计数型 DP	dp[i] = 前 i 个元素的方案数
背包 / 凑数	背包 DP	dp[j] = 容量 j 时的最优值
两个序列	双序列 DP	dp[i][j] = s1 前 i 与 s2 前 j 的结果
矩阵路径	矩阵 DP	dp[i][j] = 到达 (i,j) 的最优值

链表万能套路

场景	套路
反转	三指针（pre, cur, next）
找中点	快慢指针（fast 走 2 步，slow 走 1 步）
找倒数第 N	快指针先走 N 步，再同步走
判环	快慢指针，相遇则有环
找环入口	相遇后，一个回 head，同步走到再相遇
交点	双指针走完自己走对方的，必在交点相遇
删节点	dummy 哨兵 + pre 指针

一、数组与哈希表

0001. 两数之和 `Easy`

题意：数组中找两个数使其和为 target，返回下标。

核心思路：遍历时用哈希表记录已遍历的值和下标，对每个 nums[i] 查 target-nums[i] 是否在表中。

1
func twoSum(nums []int, target int) []int {
2
    mp := map[int]int{}
3
    for i, val := range nums {
4
        if index, exist := mp[target-val]; exist {
5
            return []int{index, i} // 找到配对
6
        }
7
        mp[val] = i // 记录当前值
8
    }
9
    return []int{}
10
}

核心破题点：用哈希表把「找配对」从 O(n) 降到 O(1)，总复杂度 O(n)
避坑指南：先查再存，避免 nums[i] 自己和自己配对（如 target=6, nums=[3,…]）

运行示例：nums = [2,7,11,15], target = 9

步骤	i	nums[i]	查找 9-nums[i]	哈希表	操作
1	0	2	查 7 → 不存在	{}	存入 {2:0}
2	1	7	查 2 → 存在(下标0)	{2:0}	返回 [0,1]

⚠️ 常见失败原因：先写入 map 再查找，导致 val == target-val 时自己匹配自己（如 nums=[3,2,4], target=6 返回 [0,0] 而非 [1,2]）。必须先查再存

0013. 罗马数字转整数 `Easy`

题意：罗马数字转整数（IV=4, VI=6）。

核心思路：遍历时如果当前值 < 下一个值（如 IV 中的 I），就减去当前值；否则加上。

1
func romanToInt(s string) int {
2
    ans := 0
3
    for i := range s {
4
        value := symbolValues[s[i]]
5
        if i < n-1 && value < symbolValues[s[i+1]] {
6
            ans -= value // 小的在前，减去（如 IV 的 I）
7
        } else {
8
            ans += value
9
        }
10
    }
11
    return ans
12
}

核心破题点：罗马数字中小的出现在大的前面表示减法（IV=5-1=4）
避坑指南：只需比较相邻两个字符的大小关系

0041. 缺失的第一个正数 `Hard`

题意：O(n) 时间 O(1) 空间找未排序数组中缺失的最小正整数。

核心思路：原地哈希——把值 v 放到下标 v-1 的位置。遍历后第一个 nums[i] != i+1 的位置就是答案。

1
for i := 0; i < n; i++ {
2
    for nums[i] >= 1 && nums[i] <= n && nums[i] != nums[nums[i]-1] {
3
        nums[nums[i]-1], nums[i] = nums[i], nums[nums[i]-1] // 交换到正确位置
4
    }
5
}
6
// 找第一个不在位置的
7
for i := 0; i < n; i++ {
8
    if nums[i] != i+1 { return i + 1 }
9
}
10
return n + 1

核心破题点：利用数组本身当哈希表，值 v 对应下标 v-1
避坑指南：交换条件必须是 nums[i] != nums[nums[i]-1]（防重复值死循环），而不是 nums[i] != i+1

运行示例：nums = [3,4,-1,1]，目标是把值 v 放到下标 v-1

步骤	i	nums[i]	操作	数组状态
1	0	3	3∈[1,4], 交换nums[0]↔nums[2]	[-1,4,3,1]
2	0	-1	-1不在[1,4], 跳过	[-1,4,3,1]
3	1	4	4∈[1,4], 交换nums[1]↔nums[3]	[-1,1,3,4]
4	1	1	1∈[1,4], 交换nums[1]↔nums[0]	[1,-1,3,4]
5	1	-1	跳过	[1,-1,3,4]
6	2	3	3已在位置2, 跳过	[1,-1,3,4]
7	3	4	4已在位置3, 跳过	[1,-1,3,4]

扫描结果：nums[1]=-1 ≠ 2，返回 2

graph TD
  A["遍历每个位置 i"] --> B{"nums[i] 在 [1,n] 且
nums[i] ≠ nums[nums[i]-1]?"}
  B -->|是| C["交换 nums[i] ↔ nums[nums[i]-1]"]
  C --> B
  B -->|否| D["i++"]
  D --> E{"i < n?"}
  E -->|是| B
  E -->|否| F["扫描找第一个 nums[i] ≠ i+1"]
  style C fill: #fff9c4, color: #1a1a1a
  style F fill: #c8e6c9, color: #1a1a1a

0049. 字母异位词分组 `Medium`

题意：把字母组成相同但顺序不同的单词分到一组。

核心思路：对每个字符串排序后作为哈希 key，相同 key 归为一组。

1
for _, str := range strs {
2
    arr := strings.Split(str, "")
3
    sort.Strings(arr)
4
    key := strings.Join(arr, "") // 排序后的字符串作 key
5
    m[key] = append(m[key], str)
6
}

核心破题点：排序后字母异位词变成相同字符串，天然适合做哈希 key
避坑指南：也可用字符计数数组（[26]int 转字符串）做 key，O(k) 而非 O(k log k)

0128. 最长连续序列 `Medium`

题意：O(n) 找未排序数组中最长连续数字序列长度。

核心思路：全部放入哈希集合，只从「序列起点」（num-1 不在集合中）开始往后数。

1
mp := map[int]bool{}
2
for _, v := range nums { mp[v] = true }
3
for key := range mp {
4
    if !mp[key-1] { // 只从起点开始数
5
        count := 1
6
        for mp[key+1] { count++; key++ }
7
        res = max(res, count)
8
    }
9
}

核心破题点：只从序列起点（num-1 不存在）开始计数，保证每个数字最多被访问 2 次
避坑指南：如果从每个数字都开始数会 O(n²)，必须跳过非起点

执行流程（nums = [100,4,200,1,3,2]）：

检查数字	num-1 在集合中？	是否为起点	向后数	序列长度
100	99不在 → 是	✅ 起点	100→(101不在)	1
4	3在 → 否	❌ 跳过	-	-
200	199不在 → 是	✅ 起点	200→(201不在)	1
1	0不在 → 是	✅ 起点	1→2→3→4→(5不在)	4 ✓max
3	2在 → 否	❌ 跳过	-	-
2	1在 → 否	❌ 跳过	-	-

结果 = 4（序列 [1,2,3,4]）。只从 3 个起点开始计数，其余 3 个跳过

0136. 只出现一次的数字 `Easy`

题意：O(n) 时间 O(1) 空间找只出现一次的数（其余出现两次）。

核心思路：全部异或，成对的抵消为 0，剩下就是答案。

1
single := 0
2
for _, num := range nums { single ^= num }
3
return single

核心破题点：异或自反性 a ^ a = 0，a ^ 0 = a
避坑指南：初始值必须为 0

0169. 多数元素 `Easy`

题意：O(n) 时间 O(1) 空间找出现次数 > n/2 的元素。

核心思路：Boyer-Moore 投票——候选人 + 计数器，遇到相同的 +1，不同的 -1，归零换人。

1
count := 0; maj := nums[0]
2
for i := 1; i < n; i++ {
3
    if count == 0 { maj = nums[i] }       // 换候选人
4
    if nums[i] == maj { count++ } else { count-- }
5
}

核心破题点：多数元素过半，抵消后一定是最后活下来的
避坑指南：count 归零时先换人再判断

0238. 除了自身以外数组的乘积 `Medium`

题意：不能用除法，O(n) 求 answer[i] = 除 nums[i] 外所有元素的乘积。

核心思路：两次遍历——左到右存左累积积，右到左乘右累积积。

1
answer[0] = 1
2
for i := 1; i < n; i++ { answer[i] = answer[i-1] * nums[i-1] } // 左累积
3
temp := 1
4
for i := n-1; i >= 0; i-- {
5
    answer[i] *= temp // 乘右累积
6
    temp *= nums[i]   // 更新右累积
7
}

核心破题点：answer[i] = 左侧所有乘积 × 右侧所有乘积，分两次遍历搞定
避坑指南：第二遍从右到左时 temp 初始为 1，先更新 answer 再更新 temp

0283. 移动零 `Easy`

题意：把数组中所有 0 移到末尾，保持非零元素相对顺序。

1
l := 0
2
for r := 0; r < len(nums); r++ {
3
    if nums[r] != 0 { nums[l], nums[r] = nums[r], nums[l]; l++ }
4
}

核心破题点：慢指针标记非零元素应该放的位置

0560. 和为 K 的子数组 `Medium`

题意：统计和为 k 的连续子数组个数。

核心思路：前缀和 + 哈希表。遍历到位置 j 时，pre[j] - k 在表里出现过几次，就有几个以 j 结尾、和为 k 的子数组。

为什么用前缀和：连续子数组 nums[i..j] 的和 = pre[j] - pre[i-1]。要它等于 k，即 pre[i-1] = pre[j] - k。所以遍历到 j 时，只要查「前面有多少个前缀和等于 pre[j] - k」即可。

1
m := map[int]int{0: 1}; pre := 0; count := 0
2
for _, num := range nums {
3
    pre += num
4
    count += m[pre-k] // 之前有多少个前缀和 = pre-k
5
    m[pre]++          // 记录当前前缀和出现次数
6
}

运行示例（nums = [1,1,1], k = 2）：

步骤	num	pre	查 pre-k=pre-2	count 累加	哈希表 m
1	1	1	查 -1 → 0	0	{0:1, 1:1}
2	1	2	查 0 → 1	1	{0:1, 1:1, 2:1}
3	1	3	查 1 → 1	2	{0:1, 1:1, 2:1, 3:1}

第 2 步 pre=2，查到 1 个 pre=0（子数组 nums[0..1]=[1,1]）；第 3 步 pre=3，查到 1 个 pre=1（子数组 nums[1..2]=[1,1]）。共 2 个

核心破题点：前缀和之差 = k，即找之前有多少个前缀和等于 pre - k
避坑指南：初始化 m[0]=1 处理「从头开始的子数组」（当 pre 恰好 = k 时 pre-k=0，要能查到）；数组含负数，不能用滑动窗口，必须用前缀和 + 哈希表

0724. 寻找数组的中心下标 `Easy`

题意：找下标使左侧和等于右侧和。

1
for _, num := range nums { right += num }
2
for i, num := range nums {
3
    right -= num        // 先减当前元素
4
    if left == right { return i }
5
    left += num         // 再加到左侧
6
}

核心破题点：用总和减去当前元素得到右侧和，无需额外数组

1207. 独一无二的出现次数 `Easy`

题意：判断每个数的出现次数是否互不相同。

1
mp := map[int]int{}
2
for _, v := range arr { mp[v]++ }      // 第一次：统计频次
3
mp2 := map[int]bool{}
4
for _, v := range mp {                  // 第二次：检查频次是否重复
5
    if mp2[v] { return false }
6
    mp2[v] = true
7
}

1431. 拥有最多糖果的孩子 `Easy`

题意：给额外糖果后是否能达到最大值。

1
maxVal := candies[0]
2
for _, v := range candies { if v > maxVal { maxVal = v } }
3
for i, v := range candies { res[i] = v + extraCandies >= maxVal }

1679. K 和数对的最大数目 `Medium`

题意：每步选和为 k 的两个数移出，求最大操作数。

1
cnt := map[int]int{}
2
for _, x := range nums {
3
    if cnt[k-x] > 0 { cnt[k-x]--; ans++ } // 找到配对
4
    else { cnt[x]++ }
5
}

1732. 找到最高海拔 `Easy`

题意：gain[i] 表示从海拔 i 到 i+1 的变化量，从海拔 0 出发，返回途中的最高海拔。

1
h := 0
2
for _, g := range gain { h += g; ans = max(ans, h) }

2215. 找出两数组的不同 `Easy`

题意：返回两个列表，分别是 nums1 中不在 nums2 的元素和 nums2 中不在 nums1 的元素（去重）。

核心思路：两个哈希集合，互相求差集。

1
func findDifference(nums1 []int, nums2 []int) [][]int {
2
    m1 := make(map[int]bool)
3
    for _, num := range nums1 { m1[num] = true }  // nums1 → 集合
4
    m2 := make(map[int]bool)
5
    for _, num := range nums2 { m2[num] = true }  // nums2 → 集合
6
    ans := make([][]int, 2)
7
    for k := range m1 { if !m2[k] { ans[0] = append(ans[0], k) } }  // nums1 独有
8
    for k := range m2 { if !m1[k] { ans[1] = append(ans[1], k) } }  // nums2 独有
9
    return ans
10
}

核心破题点：哈希集合 O(1) 查找，天然适合求差集
避坑指南：map 的 key 自动去重，无需额外处理

2352. 相等行列对 `Medium`

题意：n×n 矩阵中行和列元素完全相同的对数。

核心思路：行序列化为字符串存哈希表，列查询匹配次数。

1
func equalPairs(grid [][]int) int {
2
    mp := make(map[string]int)
3
    for i := 0; i < len(grid); i++ {        // 每行序列化
4
        s := ""
5
        for j := 0; j < len(grid[0]); j++ { s += strconv.Itoa(grid[i][j]) + " " }
6
        mp[s]++
7
    }
8
    ans := 0
9
    for j := 0; j < len(grid[0]); j++ {     // 每列查询
10
        s := ""
11
        for i := 0; i < len(grid); i++ { s += strconv.Itoa(grid[i][j]) + " " }
12
        ans += mp[s]  // 加上匹配的行数
13
    }
14
    return ans
15
}

核心破题点：行和列的比较转化为字符串匹配，哈希表 O(1) 查找
避坑指南：序列化时元素间加分隔符（如空格），防止 [1,23] 和 [12,3] 误匹配

3345. 最小可整除数位乘积 I `Easy`

题意：找 >= n 的最小整数，其各数位乘积能被 t 整除。

1
func smallestNumber(n int, t int) int {
2
    for {
3
        n1 := 1; num := n
4
        for num > 0 {
5
            n1 = num % 10 * n1   // 取每一位相乘
6
            num /= 10
7
            if n1 == 0 { break } // 含 0 则乘积为 0，一定能被整除
8
        }
9
        if n1 % t == 0 { return n }
10
        n++
11
    }
12
}

核心破题点：数位含 0 时乘积为 0，直接满足条件；数据范围小直接枚举

3731. 找出缺失的元素 `Easy`

题意：连续整数范围内缺失的数字，返回有序列表。

1
func findMissingElements(nums []int) []int {
2
    slices.Sort(nums)  // 排序
3
    ans := []int{}
4
    for i := 0; i < len(nums)-1; i++ {
5
        for j := nums[i]; j != nums[i+1]-1; j++ {  // 填充缺失的间隙
6
            ans = append(ans, j+1)
7
        }
8
    }
9
    return ans
10
}

运行示例：nums = [1,4,2,5]

步骤	nums[i]	nums[i+1]	缺失区间	ans
1	1	2	无缺失	[]
2	2	4	3	[3]
3	4	5	无缺失	[3]

核心破题点：排序后检查相邻元素差值 > 1 的间隙

二、双指针

0011. 盛最多水的容器 `Medium`

题意：两条竖线 + 底边构成容器，求最大容量。

核心思路：左右指针从两端向中间，矮的那侧移动（因为移动高的一侧不可能让面积变大）。

1
l, r := 0, len(height)-1
2
for l < r {
3
    if height[l] < height[r] {
4
        res = max(res, (r-l)*height[l]); l++
5
    } else {
6
        res = max(res, (r-l)*height[r]); r--
7
    }
8
}

核心破题点：面积 = 底 × 高，底在缩小，只有让高变大才可能增加面积 → 移动矮的一侧
避坑指南：两边等高时移动哪个都行

graph LR
    A[左右指针从两端开始] --> B{哪边矮?}
    B -->|左边矮| C[计算面积, 左指针右移]
    B -->|右边矮| D[计算面积, 右指针左移]
    C --> E{l < r?}
    D --> E
    E -->|是| B
    E -->|否| F[返回最大面积]

0015. 三数之和 `Medium`

题意：找所有和为 0 的不重复三元组。

核心思路：排序后固定一个数，再用双指针找另外两个。去重：固定的数和前一个相同就跳过。

1
sort.Ints(nums)
2
for l := 0; l < n; l++ {
3
    if nums[l] > 0 { break }                    // 最小值 > 0 不可能有解
4
    if l > 0 && nums[l] == nums[l-1] { continue } // 去重
5
    m, r := l+1, n-1
6
    for m < r {
7
        sum := nums[l] + nums[m] + nums[r]
8
        if sum == 0 {
9
            res = append(res, []int{nums[l], nums[m], nums[r]})
10
            m++; r--
11
            for m < r && nums[m] == nums[m-1] { m++ }   // 去重
12
            for m < r && nums[r] == nums[r+1] { r-- }   // 去重
13
        } else if sum > 0 { r-- } else { m++ }
14
    }
15
}

核心破题点：排序 + 固定一个 + 双指针找另外两个，三重循环降为 O(n²)
避坑指南：三层去重（固定数、左指针、右指针都要跳过重复值）

执行流程（nums = [-1,0,1,2,-1,-4]，排序后 = [-4,-1,-1,0,1,2]）：

固定 l	nums[l]	m	r	sum	动作
0	-4	1	5	-4+(-1)+2=-3<0	m++
0	-4	2	5	-4+(-1)+2=-3<0	m++
0	-4	3	5	-4+0+2=-2<0	m++
0	-4	4	5	-4+1+2=-1<0	m++，m≥r 退出
1	-1	2	5	-1+(-1)+2=0 ✅	找到[-1,-1,2]，m++,r—
1	-1	3	4	-1+0+1=0 ✅	找到[-1,0,1]，m++,r—
1	-1	4	3	m≥r 退出	-
2	-1(重复)	跳过			l=2, nums[2]==nums[1]
3	0	4	5	0+1+2=3>0	r—，r<m 退出

结果 = [[-1,-1,2], [-1,0,1]]

⚠️ 常见失败原因：在 sum == 0 分支中错误地执行了 l++（外层循环变量）而非 m++（内层左指针），导致跳过有效解

0027. 移除元素 `Easy`

题意：原地移除所有值为 val 的元素。

1
cur, lst := 0, len(nums)-1
2
for cur <= lst {
3
    if nums[lst] == val { lst-- }
4
    else if nums[cur] == val { nums[cur] = nums[lst]; lst-- }
5
    else { cur++ }
6
}
7
return lst + 1

核心破题点：双端指针，左边找 val 右边找非 val，交换
为什么交换后 cur 不前进：交换是 nums[cur] = nums[lst]，从右边换过来的元素可能也是 val（比如 nums=[3,2,2,3], val=3）。如果此时 cur++，这个换过来的 val 就被留在了前面，没被移除。所以交换分支里只把 lst--，让 cur 停在原地等下一轮重新检查新换来的元素；只有确认 nums[cur] != val 的「else 分支」才 cur++
⚠️ 常见失败原因：当 lst <= 0（数组长度为1）时直接返回 0，但若 nums[0] != val 应返回 1；交换后错误地 cur++，导致换过来的 val 残留

0042. 接雨水 `Hard`

题意：柱子高度数组，计算能接多少雨水。

核心思路：双指针 + 左右最大值。较矮的一侧决定了该位置的水位。

关键直觉（为什么矮侧决定水位）：位置 i 能接的雨水 = min(左边最高墙, 右边最高墙) - height[i]（木桶原理，水从矮的一侧溢出）。双指针的妙处在于：当 height[l] < height[r] 时，位置 l 的右侧一定存在一堵 ≥ height[r] 的墙（至少是 height[r] 自己），所以 l 的「右最大」必然 ≥ height[r] > height[l] ≥ maxLeft，于是 l 处的水量只由 maxLeft 决定，根本不用管右边具体多高！同理 height[l] ≥ height[r] 时 r 处水量只由 maxRight 决定。这就是为什么可以让矮侧先走。

1
l, r := 0, len(height)-1
2
maxLeft, maxRight := 0, 0
3
for l < r {
4
    maxLeft = max(maxLeft, height[l])   // 先更新当前位置左侧最大值
5
    maxRight = max(maxRight, height[r]) // 先更新当前位置右侧最大值
6
    if height[l] < height[r] {
7
        res += maxLeft - height[l]; l++   // 左侧矮 → 水位由 maxLeft 决定
8
    } else {
9
        res += maxRight - height[r]; r--  // 右侧矮/相等 → 水位由 maxRight 决定
10
    }
11
}

核心破题点：每个位置雨水量 = min(左最大, 右最大) - 自身高度；双指针让矮侧先走
避坑指南：先更新 max 再算雨水（用最新的 maxLeft/maxRight，包含当前 height[l]/height[r]）

柱子与雨水可视化（height = [0,1,0,2,1,0,1,3,2,1,2,1]）：

黑色 = 柱子高度，蓝色 = 接住的雨水。总雨水量 = 6

运行示例（双指针过程）：

步骤	left	right	maxL	maxR	h[l]<h[r]?	本步雨水	总计
1	0	11	0	1	是	0-0=0	0
2	1	11	1	1	否	1-1=0	0
3	1	10	1	2	是	1-1=0	0
4	2	10	1	2	是	1-0=1	1
5	3	10	2	2	否	2-2=0	1
6	3	9	2	1	否	1-1=0	1
7	3	8	2	2	否	2-2=0	1
8	3	7	2	3	是	2-2=0	1
9	4	7	2	3	是	2-1=1	2
10	5	7	2	3	是	2-0=2	4
11	6	7	2	3	是	2-1=1	5
12	7	7	3	3	相遇	3-3=0	6

graph TD
    S["初始化: l=0, r=n-1, maxL=0, maxR=0"] --> C{"height[l] < height[r] ?"}
    C -->|"是: 左更矮
右侧必有 ≥ height[r] 的墙
→ 右侧最大 > 左侧最大"| L["位置 l 的水量只由 maxL 决定
res += maxL - height[l]
l++, 更新 maxL"]
    C -->|"否: 右更矮或相等
左侧必有 ≥ height[l] 的墙
→ 左侧最大 ≥ 右侧最大"| R["位置 r 的水量只由 maxR 决定
res += maxR - height[r]
r--, 更新 maxR"]
    L --> C
    R --> C
    C -->|"l >= r 时结束"| E["返回总雨水量 = 6"]
    style S fill: #e3f2fd, color: #1a1a1a
    style E fill: #c8e6c9, color: #1a1a1a

0088. 合并两个有序数组 `Easy`

题意：把 nums2 合并到 nums1 中（nums1 末尾有空位）。

核心思路：从后往前填充，大的放后面。

1
// p1 指向 nums1 有效元素末尾，p2 指向 nums2 末尾，tail 指向合并后写入位置
2
for p1, p2, tail := m-1, n-1, m+n-1; p1 >= 0 || p2 >= 0; tail-- {
3
    if p1 == -1 {                       // nums1 已用完，只能填 nums2
4
        nums1[tail] = nums2[p2]; p2--
5
    } else if p2 == -1 {                // nums2 已用完，只能填 nums1
6
        nums1[tail] = nums1[p1]; p1--
7
    } else if nums1[p1] > nums2[p2] {   // 两数组都还有，谁大填谁（从后往前保证有序）
8
        nums1[tail] = nums1[p1]; p1--
9
    } else {
10
        nums1[tail] = nums2[p2]; p2--
11
    }
12
}

核心破题点：从后往前填，不会覆盖 nums1 还没处理的元素

0189. 轮转数组 `Medium`

题意：数组右轮转 k 位（末尾 k 个元素移到最前面），原地操作。

核心思路：三次反转——整体反转 → 前 k 个反转 → 后 n-k 个反转。

怎么想到反转的：右轮转 k 位 = 把末尾 k 个元素整体搬最前面。反转有「对称」性质：先整体反转，末尾 k 个就被翻到了最前面（但顺序是反的）；再把前 k 个和后 n-k 个分别反转回正序，就得到正确结果。三次反转刚好避免用额外数组。

1
k %= len(nums)      // 防止 k > n，轮转 k 等价于轮转 k%n
2
reverse(nums)       // ① 整体反转：末尾 k 个被翻到最前（顺序反了）
3
reverse(nums[:k])   // ② 前 k 个再反转回正序
4
reverse(nums[k:])   // ③ 后 n-k 个再反转回正序

例子（nums = [1,2,3,4,5,6,7], k = 3）：

步骤	操作	数组变化
初始	-	[1,2,3,4,5,6,7]
①	整体反转	[7,6,5,4,3,2,1]
②	前 3 反转	[5,6,7,4,3,2,1]
③	后 4 反转	[5,6,7,1,2,3,4] ✓

末尾 3 个 (5,6,7) 成功移到最前面

核心破题点：reverse(nums) + reverse(nums[:k]) + reverse(nums[k:]) 三步等价于右轮转 k

0345. 反转字符串中的元音字母 `Easy`

题意：反转字符串中的所有元音字母（aeiou，不区分大小写）。

1
l, r := 0, len(s)-1
2
b := []byte(s)
3
for l < r {
4
    for l < r && !vowels[b[l]] { l++ }
5
    for l < r && !vowels[b[r]] { r-- }
6
    b[l], b[r] = b[r], b[l]; l++; r--
7
}

0392. 判断子序列 `Easy`

题意：判断 s 是否为 t 的子序列。

1
i, j := 0, 0
2
for j < len(t) {
3
    if i < len(s) && s[i] == t[j] { i++ }
4
    j++
5
    if i == len(s) { return true }
6
}

核心破题点：t 的指针只前进不回退

0763. 划分字母区间 `Medium`

题意：划分字符串使每个字母只出现在一个片段中。

核心思路：先记录每个字母最后出现的位置，遍历时不断扩展右边界到「当前片段内所有字母的最终出现位置」；一旦遍历到片段右边界，说明该字母不会再出现，可以切一刀。

1
mp := map[rune]int{}
2
for idx, ch := range s { mp[ch] = idx }  // ① 记录每个字母最后出现的下标
3
start, end := 0, 0
4
for idx, ch := range s {
5
    if mp[ch] > end { end = mp[ch] }      // ② 扩展右边界：当前字母还会更靠后，片段必须延伸到那
6
    if idx == end {                        // ③ 到边界了：片段内字母都不会再出现，可以切分
7
        ans = append(ans, idx+1-start)    //    长度 = 右边界 - 左边界 + 1
8
        start = idx + 1                    //    下一个片段从左边界+1 开始
9
    }
10
}

核心破题点：片段右边界 = 片段内所有字母「最终出现位置」的最大值；到边界即切分，保证同一字母只落在一个片段
为什么有效：只要右边界还在扩展，就说明当前片段还没「收口」，里面的字母还有后续，必须继续；一旦 idx 追上 end，此片段已自洽，切掉不影响后面

1768. 交替合并字符串 `Easy`

题意：将 word1 和 word2 交替合并，剩余部分追加到末尾。

1
i, j := 0, 0
2
for i < m && j < n { sb.WriteByte(word1[i]); sb.WriteByte(word2[j]); i++; j++ }
3
if m > n { sb.WriteString(word1[i:]) } else if n > m { sb.WriteString(word2[j:]) }

三、滑动窗口

通用模板：右指针扩展窗口 → 判断窗口合法性 → 左指针收缩窗口 → 更新答案

graph LR
  A["right 扩展窗口"] --> B{"窗口不合法?"}
  B -->|是| C["left 收缩窗口"]
  C --> B
  B -->|否| D["更新答案"]
  D --> A

0003. 无重复字符的最长子串 `Medium`

题意：找无重复字符的最长子串长度。

核心思路：滑动窗口 + 哈希表记录字符位置。遇到重复字符时左指针跳到重复字符下一位。

1
mp := map[byte]int{}; l, res := 0, 0
2
for r := 0; r < len(s); r++ {
3
    if idx, exists := mp[s[r]]; exists && idx >= l {
4
        l = idx + 1  // 左指针跳到重复字符之后
5
    }
6
    mp[s[r]] = r
7
    res = max(res, r-l+1)
8
}

核心破题点：左指针不是一步一步走，而是直接跳到重复字符之后
避坑指南：要判断 idx >= l，因为哈希表里的位置可能在左指针之前（已不在窗口内）
⚠️ 常见失败原因：更新结果时写成 res = max(res, r-1-l) 而非 r-l+1，off-by-one 导致少算 1

0076. 最小覆盖子串 `Hard`

题意：在 s 中找包含 t 所有字符（含足够数量）的最短子串，返回它。

核心思路：滑动窗口 + count 变量跟踪还需匹配的字符种类数。

1
tmap := map[byte]int{}            // t 中各字符需要的数量
2
for _, ch := range t { tmap[ch]++ }
3
count := len(tmap)               // 还需要满足的字符种类数
4
smap := map[byte]int{}
5
l, ansL, ansR := 0, 0, len(s)
6
for r := 0; r < len(s); r++ {
7
    smap[s[r]]++
8
    if smap[s[r]] == tmap[s[r]] { count-- }   // 这种字符刚凑够 → 少一种待满足
9
    for count == 0 {                          // 窗口合法，尽量往里收缩
10
        if r-l < ansR-ansL { ansL, ansL = l, r } // 更新最短
11
        smap[s[l]]--
12
        if smap[s[l]] < tmap[s[l]] { count++ }  // 收缩后这种字符不够了 → 待满足+1
13
        l++
14
    }
15
}

例子（s = “ADOBECODEBANC”, t = “ABC”）：count 初始 = 3（A/B/C 三种）。右扩到 r=5 (“ADOBEC”) 时 A、B、C 都凑够 → count=0，窗口合法；左缩到 l=3 (“BEC”) 仍合法且更短；再缩 l=4 (“EC”) 缺 A → count=1，停止收缩，继续右扩。最终最短 = “BANC”。

核心破题点：用 count 一个变量（而非每轮遍历哈希表）O(1) 判断窗口合法性
避坑指南：收缩时判断「是否破坏合法性」的条件是 smap[s[l]] < tmap[s[l]]（数量从够变不够），不是 ==

0239. 滑动窗口最大值 `Hard`

题意：大小为 k 的滑动窗口，依次返回每个窗口内的最大值。

核心思路：单调递减队列，存下标，队首永远是当前窗口最大值。

为什么是单调队列（关键直觉）：窗口右移时，旧元素若比新元素 val 还小，那它永远不可能再当最大值——因为 val 更大、且更靠右（在窗口里待得更久）。所以一遇到新元素，就把所有比它小的旧元素从队尾弹出，保证队列从队首到队尾单调递减。队首一旦超出窗口左边界就过期弹出。

1
q := []int{} // 存下标（不是存值！方便判断过期）
2
for i, val := range nums {
3
    // ① 弹出队尾所有 ≤ 当前值的旧下标：它们以后都不可能当最大值
4
    for len(q) > 0 && nums[q[len(q)-1]] <= val { q = q[:len(q)-1] }
5
    q = append(q, i)                 // ② 当前下标入队尾
6
    if q[0] < i-k+1 { q = q[1:] }    // ③ 队首下标已滑出窗口，弹出
7
    if i >= k-1 { ans = append(ans, nums[q[0]]) } // ④ 窗口满，队首即最大值
8
}

核心破题点：单调递减队列——比新元素小的旧元素被永久淘汰，队首恒为窗口最大值
避坑指南：队列存下标而非值，才能用 q[0] < i-k+1 判断是否滑出窗口

执行流程（nums = [1,3,-1,-3,5,3,6,7], k = 3）：

步骤	i	nums[i]	队列(下标)	队列(值)	过期检查	输出
1	0	1	[0]	[1]	i<2, 不输出	-
2	1	3	[1]	[3]	i<2, 不输出	-
3	2	-1	[1,2]	[3,-1]	q[0]=1≥0, OK	nums[1]=3
4	3	-3	[1,2,3]	[3,-1,-3]	q[0]=1≥1, OK	nums[1]=3
5	4	5	[4]	[5]	q[0]=4≥2, OK	nums[4]=5
6	5	3	[4,5]	[5,3]	q[0]=4≥3, OK	nums[4]=5
7	6	6	[6]	[6]	q[0]=6≥4, OK	nums[6]=6
8	7	7	[7]	[7]	q[0]=7≥5, OK	nums[7]=7

输出 = [3,3,5,5,6,7]，每次弹出比新元素小的旧元素，保持队列单调递减

0438. 找到字符串中所有字母异位词 `Medium`

题意：异位词 = 字符种类和数量完全相同、只是排列不同的字符串（如 “abc” 和 “cba”）。返回 s 中所有长度等于 len(p)、且是 p 的异位词的子串起始下标。

核心思路：固定长度窗口 + 差值计数。用 cnt[ch] = 窗口内该字符数 - p 中该字符数，diff = 不为 0 的字符种数。diff == 0 说明窗口与 p 字符完全一致，即异位词。

1
cnt := [26]int{}; diff := 0
2
// ① 初始化：先把 s 前 len(p) 个字符的窗口与 p 比较
3
for i := 0; i < len(p); i++ {
4
    cnt[s[i]-'a']++   // 窗口多一个
5
    cnt[p[i]-'a']--   // p 多一个（相减得到差值）
6
}
7
for i := 0; i < 26; i++ { if cnt[i] != 0 { diff++ } }
8
if diff == 0 { res = append(res, 0) }
9
// ② 窗口右滑：左出右进，增量更新 cnt 和 diff
10
for i := len(p); i < len(s); i++ {
11
    out := s[i-len(p)] - 'a' // 滑出的字符
12
    cnt[out]--
13
    if cnt[out] == 0 { diff-- } else if cnt[out] == -1 { diff++ } // 由不平衡→平衡 / 由平衡→更缺
14
    in := s[i] - 'a'          // 滑入的字符
15
    cnt[in]++
16
    if cnt[in] == 0 { diff-- } else if cnt[in] == 1 { diff++ }    // 由多→平衡 / 由平衡→更多
17
    if diff == 0 { res = append(res, i-len(p)+1) }               // 平衡即异位词
18
}

核心破题点：用差值数组 + 非零个数 diff，避免每滑一步都比较 26 个字母（O(1) 判断）
⚠️ 常见失败原因：diff 更新逻辑错误——只有当 cnt 在「0 ↔ 非0」之间跨越时才改 diff，从 1→2 或 -2→-1 不算（本来就不平衡，数量变化不改变平衡性）

0643. 子数组最大平均数 I `Easy`

题意：找长度为 k 的连续子数组的最大平均值。

1
for i := 0; i < k; i++ { sum += nums[i] }
2
ans := float64(sum) / float64(k)
3
for i := k; i < len(nums); i++ { sum += nums[i] - nums[i-k]; ans = max(ans, float64(sum)/float64(k)) }

1004. 最大连续1的个数 III `Medium`

题意：把数组中最多 k 个 0 翻成 1，求翻转后能得到的最长连续 1 子数组的长度。等价于：找一个最多含 k 个 0 的最长窗口。

例子：nums = [1,1,1,0,0,0,1,1,1,1,0], k = 2 → 把中间 3 个 0 中的任意 2 个翻成 1，连上右边的 1，得到最长连续 1 长度 = 6（如下标 0~5 全为 1）。

核心思路：滑动窗口，窗口内 0 的个数 ≤ k 就合法；0 超了就收缩左边界。

1
for right := 0; right < n; right++ {
2
    if nums[right] == 0 { zeroCnt++ }
3
    for zeroCnt > k { if nums[left] == 0 { zeroCnt-- }; left++ }
4
    maxLen = max(maxLen, right-left+1)
5
}

核心破题点：「最多翻转 k 个 0」=「窗口内最多 k 个 0」

1456. 定长子串中元音的最大数目 `Medium`

1
for i := 0; i < k; i++ { if vowels[s[i]] { count++ } }
2
ans := count
3
for i := k; i < len(s); i++ {
4
    if vowels[s[i-k]] { count-- }
5
    if vowels[s[i]] { count++ }
6
    ans = max(ans, count)
7
}

⚠️ 常见失败原因：循环条件写成 i < len(s)-k 而非 i <= len(s)-k，遗漏最后一个窗口。如 s="aeiou", k=5 时循环不执行返回 0

1493. 删掉一个元素以后全为 1 的最长子数组 `Medium`

核心思路：窗口内最多 1 个 0，答案为窗口长度 - 1（必须删一个）。

1
for right := 0; right < n; right++ {
2
    if nums[right] == 0 { zeroCnt++ }
3
    for zeroCnt > 1 { if nums[left] == 0 { zeroCnt-- }; left++ }
4
    maxLen = max(maxLen, right-left)  // 注意是 right-left 不是 +1
5
}

核心破题点：必须删一个元素，所以答案是 right - left 而非 right - left + 1

四、二分查找

通用模板：left + (right-left)/2 防溢出，循环条件 left <= right

什么时候能用二分（前提：单调）：二分能「每次砍掉一半」的根本前提是——待搜索空间具有单调性，存在一个临界点把区间分成「满足某性质」和「不满足」两段（左段都满足、右段都不满足，或反之）。

数组本身升序是最直观的单调（如 0035、0074）；

更广义的「二分答案」要求目标函数随自变量单调，例如 0875 中速度越大耗时越小（total(k) 随 k 递减），于是「能否在 h 小时内吃完」存在清晰的「左非法右合法」边界。

若数据本身无序、且找不到任何随下标单调的关系，二分就没有依据，会漏解——这种情况下不能硬套二分。

为什么有时用 left < right：

left <= right（闭区间模板）：[left, right] 始终是一个有效闭区间，mid 可能就是答案，命中即返回；循环退出时 left > right（两者交错）。适合「找某个确切等于 target 的下标 / 元素确实存在」的场景（如 0033、0287 之外的普通查找）。

left < right（边界/下界模板）：循环到 left == right 才退出，此时 left（即 right）就是答案，不必再额外判断。常用于「找第一个满足某性质的位置」——如 0034 的左边界 leftBound、0035 的插入位置。注意这种写法 mid 取 left + (right-left)/2（向下取整），且更新时通常 right = mid（保留 mid 这个候选），否则 left = mid + 1，避免死循环。

一句话记忆：要「命中某个值」用 <=；要「逼近某个边界/下界」用 <。

0033. 搜索旋转排序数组 `Medium`

题意：旋转排序数组中找 target。

核心思路：二分时判断哪半边有序，再判断 target 在不在有序的那半边。

1
left, right := 0, n-1
2
for left <= right {
3
    mid := left + (right-left)/2
4
    if nums[mid] == target { return mid }
5
    if nums[mid] >= nums[left] {              // 左半有序
6
        if target >= nums[left] && target < nums[mid] { right = mid - 1 }
7
        else { left = mid + 1 }
8
    } else {                                   // 右半有序
9
        if target > nums[mid] && target <= nums[right] { left = mid + 1 }
10
        else { right = mid - 1 }
11
    }
12
}

核心破题点：旋转数组必有一半是有序的，判断 target 在不在有序的那半边
避坑指南：nums[mid] >= nums[left] 用 >= 因为 mid 可能等于 left

执行流程（nums = [4,5,6,7,0,1,2], target = 0）：

轮次	left	right	mid	nums[mid]	判断	动作
1	0	6	3	7	7≥4，左半有序	target=0 不在[4,7)，left=4
2	4	6	5	1	1<4，右半有序	target=0 不在(1,2]，right=4
3	4	4	4	0	0==target	✅ 返回 4

graph TD
    A["二分 mid"] --> B{"nums[mid] == target?"}
    B -->|是| C["返回 mid"]
    B -->|否| D{"nums[mid] >= nums[left]?"}
    D -->|是| E["左半有序"]
    D -->|否| F["右半有序"]
    E --> G{"target 在左半?"}
    F --> H{"target 在右半?"}
    G -->|是| I["right = mid-1"]
    G -->|否| J["left = mid+1"]
    H -->|是| J
    H -->|否| I

0034. 在排序数组中查找元素的第一个和最后一个位置 `Medium`

题意：升序数组中找到 target 的起始下标和结束下标（都包含），不存在返回 [-1,-1]。

核心思路：两次二分——找「第一个 ≥ target」的位置（左边界）和「第一个 > target」的位置（右边界 = 该位置−1）。

如何维护边界（二分模板）：用 left = 第一个 ≥ target 的标准写法：当 nums[mid] < target 时收缩左半（left = mid+1），否则收缩右半（right = mid-1）。结束时 left 指向第一个 ≥ target 的下标。

1
// 左边界 = 第一个 >= target 的位置
2
leftBound := func() int {
3
    l, r := 0, len(nums)-1
4
    for l <= r {
5
        mid := l + (r-l)/2
6
        if nums[mid] < target { l = mid+1 } else { r = mid-1 }
7
    }
8
    return l   // 第一个 >= target
9
}
10
// 右边界 = 第一个 > target 的位置 - 1 = 第一个 >= target+1 的位置 - 1
11
rightBound := func() int {
12
    l, r := 0, len(nums)-1
13
    for l <= r {
14
        mid := l + (r-l)/2
15
        if nums[mid] <= target { l = mid+1 } else { r = mid-1 } // 注意是 <=
16
    }
17
    return l - 1
18
}

例子（nums = [5,7,7,8,8,10], target = 8）：

左边界：第一个 ≥ 8 → 下标 3；右边界：第一个 > 8（即第一个 ≥ 9）→ 下标 5，再 −1 = 4。结果 [3,4] ✓
核心破题点：排序 + O(log n) → 必须二分；左右边界各一次二分，避免找到后线性扫描退化为 O(n)
避坑指南：两遍二分的条件不同——左边界用 nums[mid] < target，右边界用 nums[mid] <= target

0035. 搜索插入位置 `Easy`

题意：在有序数组中找 target，找到返回下标，没找到返回应插入的位置。

1
for left <= right {
2
    mid := left + (right-left)/2
3
    if nums[mid] == target { return mid }
4
    else if nums[mid] > target { right = mid - 1 }
5
    else { left = mid + 1 }
6
}
7
return left // left 就是插入位置

核心破题点：二分结束时 left 恰好指向插入位置

0074. 搜索二维矩阵 `Medium`

题意：矩阵每行从左到右升序，且每行的第一个元素 > 上一行的最后一个元素（即整体可看作一个升序一维数组）。判断 target 是否在其中。

核心思路：两次二分——把矩阵当成一维升序数组，先二分找「target 可能所在行」，再在该行内二分找 target。

1
// 把 (r,c) 映射到一维下标 idx = r*cols + c，整体二分
2
m, n := len(matrix), len(matrix[0])
3
l, r := 0, m*n-1
4
for l <= r {
5
    mid := l + (r-l)/2
6
    val := matrix[mid/n][mid%n]   // 一维下标还原成二维坐标
7
    if val == target { return true }
8
    else if val < target { l = mid+1 } else { r = mid-1 }
9
}
10
return false

为什么能当成一维：因为「每行首 > 上行列尾」的条件，矩阵的字典序和拼成一维后的大小序完全一致，所以整体二分等效于先找行、再找列。

核心破题点：矩阵满足条件时等价于一维升序数组，直接整体二分更简洁
避坑指南：用 mid/n（行）和 mid%n（列）还原坐标；注意越界检查

0153. 寻找旋转排序数组中的最小值 `Medium`

题意：一个原本升序的数组在某个「轴点」处被旋转（例如 [0,1,2,4,5,6,7] → [4,5,6,7,0,1,2]）。请找出其中的最小元素。本版本保证数组中没有重复元素。

核心思路：旋转后，数组被最小值切成两段——左半段都 >= 原数组首元素，右半段都 < 原数组首元素。用二分时，比较 nums[mid] 与 nums[left] 就能判断 mid 落在哪一段：

nums[mid] >= nums[left] → mid 在左半段（有序段），最小值一定在 mid 右边（含 mid+1 起），所以 left = mid + 1，并把 nums[left] 当作候选最小值。
nums[mid] < nums[left] → mid 在右半段（无序段），最小值一定在 mid 左边（可能就是 mid），所以 right = mid - 1，并把 nums[mid] 当作候选最小值。

1
if nums[mid] >= nums[left] { left = mid + 1; ans = min(ans, nums[left]) }
2
else { right = mid - 1; ans = nums[mid] }

例子 nums = [3,4,5,1,2]（首元素 nums[0]=3，最小值应为 1）：

left	right	mid	nums[mid] 与 nums[left]	判断	动作
0	4	2	`5 >= 3`	左段有序	ans=min(3,3)=3，left=3
3	4	3	`1 >= 1`	左段有序	ans=min(3,1)=1，left=4
4	4	4	`2 >= 2`	左段有序	ans=min(1,2)=1，left=5 → 退出

返回 ans = 1。

核心破题点：旋转数组的「有序性」只缺一处（旋转点），二分每次决定砍掉有序的一半即可
避坑指南：本题无重复才能用 nums[left] 比较；若数组含重复（154 题）必须改用 nums[right] 比较，否则会判错

0240. 搜索二维矩阵 II `Medium`

题意：在 m×n 矩阵中找 target，每行从左到右递增，每列从上到下递增。

核心思路：从右上角开始，大就左移，小就下移。

1
r, c := 0, len(matrix[0])-1
2
for r < len(matrix) && c >= 0 {
3
    if matrix[r][c] == target { return true }
4
    if matrix[r][c] > target { c-- } else { r++ }
5
}

核心破题点：右上角有「左小下大」的 BST 性质，每次排除一行或一列
避坑指南：不能用左上角，因为右和下都更大无法确定方向
⚠️ 常见失败原因：逐行二分时条件写成 target < matrix[r][0] 和 target > matrix[r][0]，当 target == matrix[r][0] 时两个条件都不满足，该行被跳过。应改为 >=

0287. 寻找重复数 `Medium`

题意：给定长度 n+1 的数组 nums，元素取值范围是 [1, n]（即值域比索引范围少一个 0）。只有一个数字重复（但可能重复多次）。找出这个重复的数。要求：不能修改原数组、只用 O(1) 额外空间、运行时间优于 O(n²)。

什么是判圈法（Floyd 判圈法 / 龟兔赛跑）：

把数组当成一张「有向图」：i → nums[i] 表示从下标 i 指向值 nums[i] 所在的下标。因为元素值域是 [1,n]、而索引有 0..n，从 0 出发必然走进某个环——而那个环的入口，正是重复出现的那个数。

为什么一定成环、且环入口=重复数？

由于值域只有 1..n，除 0 外每个值都对应一个合法下标，路径不可能无限发散，必然进入循环。
重复的那个数 dupe 至少被两个不同的下标指向（因为有两个位置的值都是 dupe），于是 dupe 这个节点有两条入边 → 它就是环的入口。

判圈法分两个阶段：

找相遇点（slow 走 1 步、fast 走 2 步）：slow = nums[slow]，fast = nums[nums[fast]]。只要存在环，二者必在环内某点相遇。
找环入口：一个指针从起点 head=0 出发，slow 从相遇点出发，两者每次都走 1 步，再次相遇处即为环入口 = 重复数。

数学直觉：设「起点到入口」距离为 a，「入口到相遇点」距离为 b，环周长为 c。相遇时 slow 走了 a+b，fast 走了 2(a+b)=a+b+k·c，解得 a+b=k·c。这意味从相遇点再走 a 步正好回到入口（绕了 k 圈）；而从起点走 a 步也到入口，所以两指针必在入口相遇。

1
slow, fast := 0, 0
2
for { slow = nums[slow]; fast = nums[nums[fast]]; if slow == fast { break } }
3
head := 0
4
for slow != head { slow = nums[slow]; head = nums[head] }
5
return slow

例子 nums = [1,3,4,2,2]（重复数是 2）：

指针路径：0 → 1 → 3 → 2 → 4 → 2 → 4 → …（2→4→2 成环，入口是节点 2）

阶段一：slow=0,fast=0 → slow=1,fast=3 → slow=3,fast=4 → slow=2,fast=4 → slow=4,fast=4（相遇于节点 4）
阶段二：head=0,slow=4 → head=1,slow=2 → head=3,slow=4 → head=2,slow=2（相遇于节点 2）

返回 2，正是重复数。

核心破题点：把「值」当作「指向下标的指针」，重复值 = 环的入口
避坑指南：不能对数组排序或用哈希表（违反「不改数组 / O(1) 空间」约束），判圈法是唯一同时满足两条约束的做法

0374. 猜数字大小 `Easy`

题意：猜 1 到 n 之间的数字，调用 guess() 获取提示（-1 更小 / 0 猜中 / 1 更大），返回猜中的数字。

1
for {
2
    mid := left + (right-left)/2
3
    res := guess(mid)
4
    if res == 0 { return mid }
5
    else if res == 1 { left = mid + 1 } else { right = mid - 1 }
6
}

0875. 爱吃香蕉的珂珂 `Medium`

题意：有 n 堆香蕉，piles[i] 是第 i 堆的数量。珂珂要在 h 小时内吃完所有香蕉，每小时她选一堆吃，吃 k 根（不足 k 根则吃完这堆），之后这一小时不能再吃别的堆。求能吃完的最小速度 k。

为什么可以二分：关键性质是「速度越大，总耗时越短」——耗时 total(k) 是关于 k 的单调递减函数。这带来两个结论：

存在一个阈值 K：当 k ≥ K 时 total(k) ≤ h（吃得完）；当 k < K 时 total(k) > h（吃不完）。
既然「答案左侧都不合法、右侧都合法」的边界单调清晰，就能用二分直接逼近这个临界点 K，而不是从 1 开始逐个试。

搜索范围：k 最小是 1，最大是 maxPiles（再以更慢的速度也能吃，但没必要更大）。

1
left, right := 1, maxPile // 速度范围 [1, 最大堆]
2
for left <= right {
3
    mid := left + (right-left)/2
4
    total := 0
5
    for _, p := range piles { total += (p + mid - 1) / mid } // 向上取整
6
    if total <= h { ans = mid; right = mid - 1 } else { left = mid + 1 }
7
}

例子 piles = [3,6,7,11], h = 8：

尝试速度 k	各堆耗时 ⌈p/k⌉	总耗时	能否 8h 吃完
4	⌈3/4⌉+⌈6/4⌉+⌈7/4⌉+⌈11/4⌉ = 1+2+2+3	8	刚好可以
3	1+2+3+4	10	不行

最小合法速度是 4。

核心破题点：吃香蕉耗时随速度单调递减 → 答案具有「左非法右合法」的边界 → 二分答案（binary search on answer）
避坑指南：每堆耗时必须向上取整 (p+mid-1)/mid，不能直接 p/mid，否则会少算一堆的时间

0004. 寻找两个正序数组的中位数 `Hard`

题意：两个正序数组找中位数，要求 O(log(m+n))。

核心思路：中位数 = 第 k 小问题。二分每次各看 k/2 个，较小的那半段不可能包含第 k 小，直接跳过。

1
func getKth(a, b []int, k int) int {
2
    if len(a) == 0 { return b[k-1] }  // a 耗尽
3
    if len(b) == 0 { return a[k-1] }  // b 耗尽
4
    if k == 1 { return min(a[0], b[0]) }  // 只剩1个
5
    midA := min(k/2-1, len(a)-1)  // 防越界
6
    midB := min(k/2-1, len(b)-1)
7
    if a[midA] < b[midB] {
8
        return getKth(a[midA+1:], b, k-(midA+1))  // a 前半段跳过
9
    } else {
10
        return getKth(a, b[midB+1:], k-(midB+1))  // b 前半段跳过
11
    }
12
}
13

14
func findMedianSortedArrays(a, b []int) float64 {
15
    total := len(a) + len(b)
16
    if total%2 == 1 {
17
        return float64(getKth(a, b, (total+1)/2))  // 奇数取中间
18
    }
19
    return float64(getKth(a,b,total/2)+getKth(a,b,total/2+1)) / 2.0  // 偶数取平均
20
}

运行示例：a = [1,3], b = [2]，总长3，找第2小

步骤	a	b	k	midA	midB	a[midA]	b[midB]	操作
1	[1,3]	[2]	2	0	0	1	2	1 < 2，跳过a[0]，k=1
2	[3]	[2]	1	-	-	-	-	k=1，返回min(3,2)=2

核心破题点：中位数转化为第 k 小问题，每次排除 k/2 个元素 → O(log(m+n))
避坑指南：midA = min(k/2-1, len(a)-1) 防止数组长度不足 k/2 时越界

五、链表

链表题万能起手式：加 dummy 哨兵节点，避免处理头节点的特殊情况。

0002. 两数相加 `Medium`

题意：两个逆序存储的链表（每个节点存一位数字，个位在前），代表两个非负整数。返回它们相加的结果链表，同样逆序存储。例如 l1 = 2→4→3 表示 342，l2 = 5→6→4 表示 465，结果应为 807 → 7→0→8。

它在干什么（逐位模拟小学加法）：

dummy 哨兵节点：结果链表的「假头」，这样不用特殊处理「第一个节点」的赋值，tail 始终指向已构造部分的末尾，新节点接到 tail.Next。最后返回 dummy.Next 才是真正的头。
carry 进位：每一位相加可能产生进位（如 7+8=15，个位留 5、进 1），carry 带到下一位。
循环条件 l1 != nil || l2 != nil：只要两条链表还有任意一条没走完（或还有进位）就继续；不足位补 0。

1
dummy := &ListNode{}; tail := dummy; carry := 0
2
for l1 != nil || l2 != nil {
3
    sum := carry
4
    if l1 != nil { sum += l1.Val; l1 = l1.Next }
5
    if l2 != nil { sum += l2.Val; l2 = l2.Next }
6
    sum, carry = sum%10, sum/10 // 当前位 = sum%10，进位 = sum/10
7
    tail.Next = &ListNode{Val: sum}; tail = tail.Next
8
}
9
if carry > 0 { tail.Next = &ListNode{Val: carry} } // 最后还有进位，补一位
10
return dummy.Next

逐位演算 l1 = 2→4→3（342），l2 = 5→6→4（465），正确和 807：

轮次	l1.Val	l2.Val	carry进	原始和	当前位(和%10)	新carry(和/10)	结果接的节点
1	2	5	0	7	7	0	7
2	4	6	0	10	0	1	0
3	3	4	1	8	8	0	8
4	-	-	0	结束	-	-	-

得到 7→0→8（即 807），正确。

核心破题点：dummy 哨兵统一头节点处理 + carry 进位贯穿每一位
避坑指南：循环条件别写成 l1 != nil && l2 != nil，否则长度不等时长的那条剩余位会被丢掉；且结束后要检查 carry 是否还有进位

0019. 删除链表的倒数第 N 个结点 `Medium`

核心思路：快指针先走 N 步，再同步走。快指针到尾时慢指针在倒数第 N+1 个。

1
dummy := &ListNode{Next: head}
2
left, right := dummy, head
3
for i := 0; i < n; i++ { right = right.Next }
4
for right != nil { left = left.Next; right = right.Next }
5
left.Next = left.Next.Next  // 删除
6
return dummy.Next

核心破题点：快指针先走 N 步制造差距，dummy 防止删头节点

0021. 合并两个有序链表 `Easy`

1
dummy := &ListNode{}; tail := dummy
2
for l1 != nil && l2 != nil {
3
    if l1.Val < l2.Val { tail.Next = l1; l1 = l1.Next } else { tail.Next = l2; l2 = l2.Next }
4
    tail = tail.Next
5
}
6
if l1 != nil { tail.Next = l1 } else { tail.Next = l2 }
7
return dummy.Next

0023. 合并 K 个升序链表 `Hard`

核心思路：分治——两两合并，类似归并排序。

1
for len(lists) > 1 {
2
    var merged []*ListNode
3
    for i := 0; i < len(lists); i += 2 {
4
        if i+1 >= len(lists) { merged = append(merged, lists[i]); continue }
5
        merged = append(merged, mergeTwo(lists[i], lists[i+1]))
6
    }
7
    lists = merged
8
}

核心破题点：两两合并把 K 个链表的合并降到 O(N log K)
避坑指南：也可用最小堆每次取最小节点

分治合并示意（K=4 个链表）：

graph TD
    subgraph "第0轮"
        L1["链表1: 1→4→5"]
        L2["链表2: 1→3→4"]
        L3["链表3: 2→6"]
        L4["链表4: 3→7"]
    end
    subgraph "第1轮: 两两合并"
        M12["合并1+2: 1→1→3→4→4→5"]
        M34["合并3+4: 2→3→6→7"]
    end
    subgraph "第2轮: 最终合并"
        F["合并M12+M34: 1→1→2→3→3→4→4→5→6→7"]
    end
    L1 --> M12
    L2 --> M12
    L3 --> M34
    L4 --> M34
    M12 --> F
    M34 --> F
    style F fill: #c8e6c9, color: #1a1a1a

每轮链表数减半，共 log K 轮，每轮总比较次数 O(N)

0024. 两两交换链表中的节点 `Medium`

题意：每两个相邻节点交换位置，返回头节点。

1
dummy := &ListNode{Next: head}; pre := dummy
2
for head != nil && head.Next != nil {
3
    first, second := head, head.Next
4
    pre.Next = second
5
    first.Next = second.Next
6
    second.Next = first
7
    pre = first; head = first.Next
8
}
9
return dummy.Next

0025. K 个一组翻转链表 `Hard`

核心思路：每 k 个为一组，断开 → 反转 → 接回。用 pre 和 tail 标记每组的前驱和尾。

1
dummy := &ListNode{Next: head}; pre, tail := dummy, dummy
2
for {
3
    for i := 0; i < k; i++ {
4
        tail = tail.Next
5
        if tail == nil { return dummy.Next } // 不够 k 个
6
    }
7
    next := tail.Next; groupHead := pre.Next
8
    tail.Next = nil
9
    reversedHead := reverseList(groupHead) // 反转
10
    pre.Next = reversedHead
11
    groupHead.Next = next  // 原头变尾，接下一组
12
    pre, tail = groupHead, groupHead
13
}

核心破题点：断开 → 反转 → 接回三步走，pre 和 tail 是连接桥梁

0138. 随机链表的复制 `Medium`

题意：深拷贝一个带 random 指针的链表，返回新链表头节点。

核心思路：原地交叉复制法（O(1) 空间）。

1
// 1. 在每个节点后插入复制节点 A→A'→B→B'
2
// 2. 设置 random: now.Next.Random = now.Random.Next
3
// 3. 断开分离

核心破题点：交叉复制后，原节点.Random.Next 就是 random 对应的复制节点

0141. 环形链表 `Easy`

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

1
fast, slow := head, head
2
for fast != nil && fast.Next != nil {
3
    fast = fast.Next.Next; slow = slow.Next
4
    if fast == slow { return true }
5
}
6
return false

核心破题点：快慢指针在环内必然相遇

0142. 环形链表 II `Medium`

题意：找到链表环的入口节点，无环返回 null。

核心思路：快慢指针相遇后，一个回 head 同步走，再次相遇即环入口。

1
// 第一阶段：找相遇点
2
// 第二阶段：head 和 slow 同速走
3
for head != slow { head = head.Next; slow = slow.Next }
4
return head

核心破题点：数学证明 a = c（头到入口 = 相遇点到入口）

指针追踪（链表: 3→2→0→-4→(回到2)，环入口=节点2）：

graph LR
    H["head(3)"] -->|" a=1步 "| E["入口(2)"]
    E -->|" b=1步 "| N0["(0)"]
    N0 -->|" 1步 "| M["相遇点(-4)"]
    M -->|" c=1步 "| E
    style E fill: #c8e6c9, stroke: #333, color: #1a1a1a
    style M fill: #fff9c4, stroke: #333, color: #1a1a1a

执行流程：

阶段	fast	slow	说明
初始	3	3	都从 head 出发
第1步	2→0	2	fast走2步, slow走1步
第2步	-4→2→0	0	fast走2步, slow走1步
第3步	-4	-4	✅ 在-4相遇
第二阶段	head=3	slow=-4	一个回head，同速走
第1步	2	2	✅ 在节点2相遇=环入口

关键：a = c，所以从 head 和相遇点同速走，必在入口相遇

0146. LRU 缓存 `Medium`

题意：实现 O(1) 的 get 和 put 的 LRU 缓存，超容量时淘汰最久未使用的。

核心思路：哈希表 + 双向链表。哈希表 O(1) 查找，双向链表 O(1) 调整顺序。

1
type LRUCache struct {
2
    cache    map[int]*DLinkedNode
3
    head, tail *DLinkedNode  // 虚拟头尾
4
    capacity int
5
}
6
// Get: 查到后移到头部
7
// Put: 新节点加头部，超容淘汰尾部

核心破题点：哈希表负责定位，双向链表负责顺序，两者结合 = O(1) LRU
避坑指南：淘汰尾节点后必须同时从 map 中 delete；虚拟头尾节点简化边界处理

双向链表示意（capacity=2，操作序列: put(1,1), put(2,2), get(1), put(3,3)）：

graph LR
    subgraph "put(1,1)后"
        H1["head⟷"] --> N1["key=1,val=1"] --> T1["⟷tail"]
    end
    subgraph "put(2,2)后"
        H2["head⟷"] --> N2A["key=2,val=2"] --> N2B["key=1,val=1"] --> T2["⟷tail"]
    end
    subgraph "get(1)后: 1移到头部"
        H3["head⟷"] --> N3A["key=1,val=1"] --> N3B["key=2,val=2"] --> T3["⟷tail"]
    end
    subgraph "put(3,3)后: 淘汰尾部key=2"
        H4["head⟷"] --> N4A["key=3,val=3"] --> N4B["key=1,val=1"] --> T4["⟷tail"]
    end
    style N1 fill: #e3f2fd, color: #1a1a1a
    style N2A fill: #e3f2fd, color: #1a1a1a
    style N3A fill: #c8e6c9, color: #1a1a1a
    style N4A fill: #fff9c4, color: #1a1a1a

绿=刚访问移到头部；黄=新插入；蓝=普通节点。头部=最近使用，尾部=最久未用

0148. 排序链表 `Medium`

题意：对链表排序，要求 O(n log n) 时间。

核心思路：归并排序——快慢指针找中点，递归排序，合并。

1
slow, fast := head, head.Next  // fast 从 head.Next 出发
2
for fast != nil && fast.Next != nil { slow = slow.Next; fast = fast.Next.Next }
3
rightHead := slow.Next; slow.Next = nil  // 断开
4
return merge(sortList(head), sortList(rightHead))

核心破题点：链表归并天然适合——找中点用快慢指针，合并用双指针
避坑指南：fast 初始必须是 head.Next 而非 head，否则偶数长度分割不均

0160. 相交链表 `Easy`

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

核心思路：双指针走完自己走对方的，总路程相同，必在交点相遇。

1
a, b := headA, headB
2
for a != b {
3
    if a == nil { a = headB } else { a = a.Next }
4
    if b == nil { b = headA } else { b = b.Next }
5
}
6
return a

核心破题点：两指针走 lenA + lenB 步后必然同步到达交点或 nil

0206. 反转链表 `Easy`

1
var pre *ListNode; cur := head
2
for cur != nil {
3
    temp := cur.Next  // 暂存
4
    cur.Next = pre     // 反转
5
    pre = cur          // 前进
6
    cur = temp
7
}
8
return pre

核心破题点：暂存 next 防断链，三指针逐步推进

0234. 回文链表 `Easy`

核心思路：转数组 + 双指针比较（简单版）。进阶：快慢找中点 + 反转后半段 + 比较。

0328. 奇偶链表 `Medium`

1
odd := head; even := head.Next; evenHead := even
2
for even != nil && even.Next != nil {
3
    odd.Next = odd.Next.Next; even.Next = even.Next.Next
4
    odd = odd.Next; even = even.Next
5
}
6
odd.Next = evenHead  // 奇链表接偶链表

2095. 删除链表的中间节点 `Medium`

1
slow, fast := head, head; var pre *ListNode
2
for fast != nil && fast.Next != nil {
3
    fast = fast.Next.Next; pre = slow; slow = slow.Next
4
}
5
pre.Next = pre.Next.Next

2130. 链表最大孪生和 `Medium`

题意：将链表前半与反转的后半对应位置配对，求各对之和的最大值。

核心思路：快慢找中点 → 反转后半段 → 双指针同步走求最大和。

1
// 1. 快慢找中点
2
// 2. 反转后半段
3
// 3. x, y := head, reversedHead; 求 max(x.Val + y.Val)

六、栈与单调栈

0020. 有效的括号 `Easy`

1
m := map[byte]byte{')': '(', ']': '[', '}': '{'}
2
stk := []byte{}
3
for i := 0; i < len(s); i++ {
4
    if cur, exist := m[s[i]]; exist {        // 右括号
5
        if len(stk) == 0 || stk[len(stk)-1] != cur { return false }
6
        stk = stk[:len(stk)-1]
7
    } else { stk = append(stk, s[i]) }        // 左括号入栈
8
}
9
return len(stk) == 0

0032. 最长有效括号 `Hard`

核心思路：栈存下标，栈底始终保存最后一个不匹配的位置。

1
stack := []int{-1}  // 初始 -1 作为基准
2
for i, c := range s {
3
    if c == '(' { stack = append(stack, i) }
4
    else {
5
        stack = stack[:len(stack)-1]  // 弹出
6
        if len(stack) == 0 { stack = append(stack, i) }  // 栈空，更新基准
7
        else { ans = max(ans, i-stack[len(stack)-1]) }    // 计算长度
8
    }
9
}

核心破题点：栈底保存「最后一个不匹配位置」，当前下标减栈顶就是有效长度
避坑指南：栈空时要把当前右括号下标入栈作为新基准
⚠️ 常见失败原因：用 ans 累加所有匹配括号对的总数，而非追踪最长连续有效子串长度。如 "()(()" 返回 4 而非正确答案 2

0084. 柱状图中最大的矩形 `Hard`

核心思路：单调递增栈。当前柱子比栈顶矮时弹出栈顶，以弹出柱子为高计算面积。

1
stack := []int{}
2
for i := 0; i <= n; i++ {
3
    for len(stack) > 0 && (i == n || heights[i] < heights[stack[len(stack)-1]]) {
4
        h := heights[stack[len(stack)-1]]; stack = stack[:len(stack)-1]
5
        left := -1; if len(stack) > 0 { left = stack[len(stack)-1] }
6
        ans = max(ans, h*(i-left-1))  // 宽 = i - left - 1
7
    }
8
    stack = append(stack, i)
9
}

核心破题点：每个柱子为高的最大矩形由左右第一个比它矮的柱子决定，单调栈 O(1) 找到
避坑指南：遍历结束后要清算栈中剩余（右边界为 n）；加哨兵 heights[n]=0 简化

柱状图可视化（heights = [2,1,5,6,2,3]）：

↑ 红色柱（高6）以自己为高，向左扩展到高5，宽=2，面积=5×2=10（最大矩形）

执行流程（heights = [2,1,5,6,2,3]，哨兵 heights[6]=0）：

步骤	i	当前柱高	栈（下标）	动作	计算面积
1	0	2	[]	入栈	-
2	1	1	[0]	1<2，弹出0	2×(1-(-1)-1)=2
3	1	1	[]	入栈	-
4	2	5	[1]	5>1，入栈	-
5	3	6	[1,2]	6>5，入栈	-
6	4	2	[1,2,3]	2<6，弹出3	6×(4-2-1)=6
7	4	2	[1,2]	2<5，弹出2	5×(4-1-1)=10 ✓max
8	4	2	[1]	2>1，入栈	-
9	5	3	[1,4]	3>2，入栈	-
10	6	0(哨兵)	[1,4,5]	0<3，弹出5	3×(6-4-1)=3
11	6	0	[1,4]	0<2，弹出4	2×(6-1-1)=8
12	6	0	[1]	0<1，弹出1	1×(6-(-1)-1)=6

最大面积 = 10（柱子高5，宽2，即下标2-3的5和6）

0155. 最小栈 `Medium`

题意：实现 push/pop/top/getMin 均为 O(1) 的栈。

核心思路：辅助栈同步维护最小值。

1
func Push(value int) {
2
    num = append(num, value)
3
    minNum = append(minNum, min(value, minNum[top]))  // 同步压入当前最小
4
}
5
func GetMin() int { return minNum[top] }

0394. 字符串解码 `Medium`

题意：解码 “3[a2[c]]” → “accaccacc”，数字表示后面方括号内字符串的重复次数。

核心思路：遇到 [ 压栈保存上下文，遇到 ] 弹栈恢复并拼接。

1
if s[i] == '[' {
2
    strStack = append(strStack, currStr)  // 保存当前字符串
3
    numStack = append(numStack, currNum)  // 保存重复次数
4
    currStr = ""; currNum = 0             // 重置
5
} else if s[i] == ']' {
6
    prev := strStack[len(strStack)-1]; strStack = strStack[:len(strStack)-1]
7
    times := numStack[len(numStack)-1]; numStack = numStack[:len(numStack)-1]
8
    currStr = prev + strings.Repeat(currStr, times)  // 拼接
9
}

核心破题点：[ 入栈保存上下文，] 出栈恢复上下文
避坑指南：数字可能多位，需 currNum = currNum*10 + int(s[i]-'0')

执行流程（s = “3[a2[c]]”）：

步骤	字符	动作	currStr	currNum	strStack	numStack
1	‘3’	累积数字	""	3	[]	[]
2	’[’	压栈保存上下文，重置	""	0	[""]	[3]
3	‘a’	拼入currStr	“a”	0	[""]	[3]
4	‘2’	累积数字	“a”	2	[""]	[3]
5	’[’	压栈保存上下文，重置	""	0	["",“a”]	[3,2]
6	‘c’	拼入currStr	“c”	0	["",“a”]	[3,2]
7	’]’	弹栈：prev=“a”, times=2 → “a”+“cc”=“acc”	“acc”	0	[""]	[3]
8	’]’	弹栈：prev="", times=3 → ""+“accaccacc”=“accaccacc”	“accaccacc”	0	[]	[]

结果 = “accaccacc”

0735. 小行星碰撞 `Medium`

题意：行星数组，正数向右、负数向左，同方向不碰，相向碰撞时大的消灭小的、等大同时消灭，返回碰撞后剩余的行星。

核心思路：栈模拟。只有「栈顶向右 + 当前向左」才碰撞。

1
for _, a := range asteroids {
2
    alive := true
3
    for alive && a < 0 && len(st) > 0 && st[len(st)-1] > 0 {
4
        alive = st[len(st)-1] < -a  // 当前是否存活
5
        if st[len(st)-1] <= -a { st = st[:len(st)-1] }  // 栈顶爆炸
6
    }
7
    if alive { st = append(st, a) }
8
}

核心破题点：只有方向相反（右←左）才碰撞，同向或反向不碰

0739. 每日温度 `Medium`

题意：对每天温度，找之后第一个更高温度距当前隔几天，没有则填 0。

核心思路：单调递减栈（存下标），遇到更高温度时弹出填值。

1
for i := 0; i < len(T); i++ {
2
    for len(idx) > 0 && T[i] > T[idx[len(idx)-1]] {
3
        ans[idx[len(idx)-1]] = i - idx[len(idx)-1]
4
        idx = idx[:len(idx)-1]
5
    }
6
    idx = append(idx, i)
7
}

核心破题点：栈存「还没找到更高温度」的下标，遇到更大就弹出

graph TD
    A["i=0, T[0]=73
栈空, 入栈"] --> B["i=1, T[1]=74 > 73
弹出73, ans[0]=1
入栈74"]
    B --> C["i=2, T[2]=75 > 74
弹出74, ans[1]=1
入栈75"]
    C --> D["i=3, T[3]=71 < 75
直接入栈"]
    D --> E["i=4, T[4]=69 < 71
直接入栈"]
    E --> F["i=5, T[5]=72 > 69
弹出69, ans[4]=1
72 > 71, 弹出71, ans[3]=2
72 < 75, 入栈72"]
    F --> G["i=6, T[6]=76 > 72
弹出72, ans[5]=1
76 > 75, 弹出75, ans[2]=4
入栈76"]
    style A fill: #e8f5e9, color: #1a1a1a
    style G fill: #fff9c4, color: #1a1a1a

2390. 从字符串中移除星号 `Medium`

题意：字符串中星号 * 删除左侧最近的非星号字符，返回最终字符串。

核心思路：栈模拟——遇到 * 弹出栈顶，遇到字母压栈。

1
func removeStars(s string) string {
2
    var res []rune
3
    for _, c := range s {
4
        if c != '*' {
5
            res = append(res, c)  // 字母入栈
6
        } else {
7
            res = res[:len(res)-1]  // 星号弹出栈顶
8
        }
9
    }
10
    return string(res)
11
}

运行示例：s = “leet**cod*e”

步骤	字符	操作	栈状态
1	l	入栈	l
2	e	入栈	le
3	e	入栈	lee
4	t	入栈	leet
5	*	弹出t	lee
6	*	弹出e	le
7	c	入栈	lec
8	o	入栈	leco
9	d	入栈	lecod
10	*	弹出d	leco
11	e	入栈	lecoe

核心破题点：星号删除左侧字符 = 栈的弹出操作，天然适合栈模拟

七、二叉树

树题万能套路：想清楚三件事——①当前节点做什么 ②左子树递归返回什么 ③右子树递归返回什么

graph TD
    A["树题类型判断"] --> B{"要遍历整棵树?"}
    B -->|是| C["DFS/BFS 遍历"]
    B -->|否| D{"需要左右子树信息?"}
    D -->|是| E["后序遍历
return 值给父节点"]
    D -->|否| F["前序遍历
传值给子节点"]
    C --> G{"需要按层?"}
    G -->|是| H["BFS 层序"]
    G -->|否| I["DFS 递归"]

0094. 二叉树的中序遍历 `Easy`

1
func dfs(node *TreeNode, res *[]int) {
2
    if node == nil { return }
3
    dfs(node.Left, res)        // 左
4
    *res = append(*res, node.Val) // 根
5
    dfs(node.Right, res)       // 右
6
}

核心破题点：中序 = 左→根→右，BST 中序遍历是升序序列

0098. 验证二叉搜索树 `Medium`

核心思路：递归 + 范围限制。每个节点必须在 (lower, upper) 开区间内。

1
func helper(node *TreeNode, lower, upper int) bool {
2
    if node == nil { return true }
3
    if node.Val <= lower || node.Val >= upper { return false }
4
    return helper(node.Left, lower, node.Val) && helper(node.Right, node.Val, upper)
5
}

核心破题点：BST 约束是整棵子树的范围，不是仅父子比较
避坑指南：区间是开区间，条件用 <= 和 >=
⚠️ 常见失败原因：初始上下界用 -1<<31 和 1<<31-1（int32 范围），但节点值范围恰好是 [-2^31, 2^31-1]，导致边界值被误判。应使用 math.MinInt64/math.MaxInt64

0101. 对称二叉树 `Easy`

题意：判断一棵二叉树是否「轴对称」——即整棵树以中轴线左右镜像对称（不是判断左右子树结构相同，而是要求互为镜像）。

为什么最后要两个互换比较：判断「对称」不能直接比较左子树 == 右子树，而要比较左子树的左孩子 ↔ 右子树的右孩子（外侧对外侧）、以及左子树的右孩子 ↔ 右子树的左孩子（内侧对内侧）。这就是 check(left.Left, right.Right) 与 check(left.Right, right.Left) 的「交错」递归——把左子树「翻转」后再和右子树比。

1
func check(left, right *TreeNode) bool {
2
    if left == nil && right == nil { return true }
3
    if left == nil || right == nil { return false }
4
    return left.Val == right.Val &&
5
        check(left.Left, right.Right) &&   // 交错比较
6
        check(left.Right, right.Left)
7
}

镜像比较示意（节点值标注，箭头表示比较配对）：

1
        1
2
       / \
3
      2   2      ← 比较 2 和 2 的值
4
     / \ / \
5
    3  4 4  3    ← 左2的左3 ↔ 右2的右3（外侧）
6
                ← 左2的右4 ↔ 右2的左4（内侧）

核心破题点：对称 = 左右子树互为镜像，递归时「左左配右右、左右配右左」交错比较
避坑指南：容易写成 check(left, right) 直接比两棵子树（那是判断「相等」而非「对称」）；务必把 Left/Right 交叉配对

0102. 二叉树的层序遍历 `Medium`

核心思路：BFS 用队列，或 DFS 传层级参数。

1
// DFS 版
2
func level(node *TreeNode, l int) {
3
    if node == nil { return }
4
    if l >= len(res) { res = append(res, []int{}) }  // 新层
5
    res[l] = append(res[l], node.Val)
6
    level(node.Left, l+1)
7
    level(node.Right, l+1)
8
}

0104. 二叉树的最大深度 `Easy`

1
func maxDepth(root *TreeNode) int {
2
    if root == nil { return 0 }
3
    return max(maxDepth(root.Left), maxDepth(root.Right)) + 1
4
}

核心破题点：max(左深度, 右深度) + 1

0105. 从前序与中序遍历序列构造二叉树 `Medium`

核心思路：前序第一个是根，在中序中找根位置分左右。

1
root := &TreeNode{Val: preorder[0]}
2
i := indexOf(inorder, preorder[0])
3
root.Left = buildTree(preorder[1:1+i], inorder[:i])
4
root.Right = buildTree(preorder[1+i:], inorder[i+1:])

核心破题点：前序定根，中序分左右
避坑指南：切片边界容易错，左子树前序范围 preorder[1 : 1+左子树长度]

0108. 将有序数组转换为二叉搜索树 `Easy`

1
func bst(l, h int) *TreeNode {
2
    if l > h { return nil }
3
    mid := (l + h) / 2
4
    return &TreeNode{Val: nums[mid], Left: bst(l, mid-1), Right: bst(mid+1, h)}
5
}

核心破题点：取中点为根天然保证平衡

0114. 二叉树展开为链表 `Medium`

题意：把一棵二叉树「原地」展开成一个只有右指针的单链表，且节点顺序保持原树的先序遍历顺序（根→左→右）。要求原地修改，不能新建节点。

展开前后对照（先序遍历应为 1→2→3→4→5→6）：

1
展开前：                展开后（仅右指针的链表）：
2
    1                       1
3
   / \                       \
4
  2   5                       2
5
 / \   \                       \
6
3   4   6                       3
7
                                 \
8
                                  4
9
                                   \
10
                                    5
11
                                     \
12
                                      6

怎么做：对当前节点 cur，若它有左子树，就：

找到左子树里最右的节点 pre（它是左子树先序遍历的最后一个）；
把 cur 的原右子树接到 pre.Right 上（保住右边）；
把 cur.Right 改成 cur.Left（左子树接到右边），并把 cur.Left 置空；
cur 向右走一步，重复直到所有左子树被「搬」到右子树链上。

1
cur := root
2
for cur != nil {
3
    if cur.Left != nil {
4
        pre := cur.Left
5
        for pre.Right != nil { pre = pre.Right }  // 找左子树最右节点
6
        pre.Right = cur.Right  // 接上原右子树
7
        cur.Right = cur.Left   // 左变右
8
        cur.Left = nil
9
    }
10
    cur = cur.Right
11
}

核心破题点：类似 Morris 遍历，把左子树插入到当前节点和右子树之间，保持先序顺序
避坑指南：循环条件是 cur != nil 不是 cur.Left != nil
⚠️ 常见失败原因：循环条件写成 for cur.Left != nil，当当前节点无左子树时循环退出，但右子树深处可能仍有左子树需要展开

0124. 二叉树中的最大路径和 `Hard`

核心思路：递归返回「单边最大值」，同时在每个节点计算「完整路径」更新答案。

1
func dfs(root *TreeNode) int {
2
    if root == nil { return 0 }
3
    left := max(dfs(root.Left), 0)   // 负分支舍弃
4
    right := max(dfs(root.Right), 0)
5
    ans = max(ans, left+right+root.Val)        // 完整路径（以当前为顶点）
6
    return max(left, right) + root.Val          // 单边路径（传给父节点）
7
}

核心破题点：返回值和答案更新是两回事——返回单边（可拼接），答案取双边（完整路径）
避坑指南：负值分支用 max(x, 0) 舍弃

单边 vs 双边路径示意：

graph TD
    subgraph "返回值=单边（传给父节点）"
        A["节点(10)"] --> B["左子:max(左,0)+10"]
        A --> C["右子:max(右,0)+10"]
        A --> D["返回: max(B,C)"]
    end
    subgraph "答案=双边（完整路径，以当前为顶点）"
        E["节点(10)"] --> F["左分支"]
        E --> G["右分支"]
        F --> H["ans更新: 左+右+10"]
    end
    style D fill: #e3f2fd, color: #1a1a1a
    style H fill: #c8e6c9, color: #1a1a1a

蓝色 = 返回给父节点的单边路径（只能选左或右）；绿色 = 在当前节点计算的双边路径（左右都走，更新全局答案）

0199. 二叉树的右视图 `Medium`

题意：从二叉树右侧看过去，返回每层最右节点的值（从上到下）。

核心思路：层序遍历取每层最后一个节点。

1
// BFS 每层最后一个就是右视图
2
res = append(res, values[len(values)-1])

0226. 翻转二叉树 `Easy`

1
root.Left, root.Right = root.Right, root.Left
2
invertTree(root.Left)
3
invertTree(root.Right)
4
return root

0230. 二叉搜索树中第 K 小的元素 `Medium`

核心思路：BST 中序遍历是升序，第 k 小 = 中序第 k 个。

1
func dfs(node *TreeNode) bool {
2
    if node == nil { return false }
3
    if dfs(node.Left) { return true }
4
    k--
5
    if k == 0 { res = node.Val; return true }  // 找到就终止
6
    return dfs(node.Right)
7
}

0236. 二叉树的最近公共祖先 `Medium`

题意：在二叉树中找两个节点 p 和 q 的最近公共祖先（LCA）。

1
if root == nil || root == p || root == q { return root }
2
left := lowestCommonAncestor(root.Left, p, q)
3
right := lowestCommonAncestor(root.Right, p, q)
4
if left != nil && right != nil { return root }  // 左右都找到 → 当前是 LCA
5
if left == nil { return right }
6
return left

核心破题点：p 和 q 分别在左右子树时当前节点就是 LCA

递归返回值示意（root=3, p=5, q=1）：

graph TD
    N3["3 (root)"] --> N5["5"]
    N3 --> N1["1"]
    N5 --> N6["6"]
    N5 --> N2["2"]
    N1 --> N0["0"]
    N1 --> N8["8"]
    style N5 fill: #c8e6c9, stroke: #333, color: #1a1a1a
    style N1 fill: #fff9c4, stroke: #333, color: #1a1a1a
    style N3 fill: #ffcdd2, stroke: #333, color: #1a1a1a

节点	左返回	右返回	判断
6	nil	nil	返回 nil
2	nil	nil	返回 nil
5	nil	nil	5==p → 返回 5
0	nil	nil	返回 nil
8	nil	nil	返回 nil
1	nil	nil	1==q → 返回 1
3	5(非nil)	1(非nil)	左右都找到 → 3 是 LCA

绿=p，黄=q，红=LCA。p 和 q 分别在左右子树 → 根节点就是 LCA

0437. 路径总和 III `Medium`

题意：二叉树里，找出路径和等于 targetSum 的路径数目。这里的「路径」不要求从根开始、也不要求到叶子结束——只要是一条从上往下、连续、不拐弯的链（任意节点起、任意节点止）即可。

前缀和思路（类比数组里的「两数和」）：

设 s(X) = 从根到节点 X 沿路所有节点值之和（前缀和）。
若某条路径从祖先 A 的子节点一直连到 X，其路径和 = s(X) - s(A)（A 是 X 的某个祖先，s(A) 是到 A 为止的前缀和）。
我们要求 s(X) - s(A) == targetSum，即 s(A) == s(X) - targetSum。所以：以 X 结尾、和为 targetSum 的路径数 = 当前路径上「前缀和等于 s(X)-targetSum」的祖先个数，用哈希表 cnt 实时统计。

为什么要回溯：cnt 只应记录「从根到当前 X 这一条路径上」出现过的前缀和。DFS 访问完 X 的左子树要转向右子树时，必须把 X 的贡献 cnt[s]-- 撤掉——否则别的兄弟分支的祖先会被错误计入。

1
cnt := map[int]int{0: 1} // 0:1 处理「从当前节点本身开始」的路径
2
func dfs(node *TreeNode, s int) {
3
    s += node.Val
4
    ans += cnt[s-targetSum]  // 几个祖先的前缀和 = s-targetSum，就有几条合法路径
5
    cnt[s]++
6
    dfs(node.Left, s); dfs(node.Right, s)
7
    cnt[s]--  // 回溯！离开本节点，撤销它对 cnt 的贡献
8
}

例子 targetSum = 8，树：10 / \ 5 -3 / \ \ 3 2 11 / \ 3 -2 1

到节点 3（左子树，路径 10→5→3，前缀和 s=18）：cnt 中找 18-8=10，根节点前缀和正好是 10 → 计 1 条（路径 5→3，和 8）。
到叶子 3（10→5→3→3，s=21）：找 21-8=13，曾经出现 13（根10+左5）→ +1（路径 5→3→3，和 8）。
到 11（前缀和 10-3+11=18）：找 18-8=10 → +1（路径 -3→11，和 8）。等等。最终合法路径共 3 条。
核心破题点：前缀和差 = targetSum；哈希表存祖先前缀和；回溯撤销计数防止跨子树误计
避坑指南：cnt 初始放 {0:1} 是为了覆盖「路径从当前节点自身开始」的情况；忘记回溯会让不同分支的祖先互相串扰

0543. 二叉树的直径 `Easy`

核心思路：经过每个节点的最长路径 = 左深度 + 右深度。

1
func depth(node *TreeNode) int {
2
    if node == nil { return 0 }
3
    l := depth(node.Left); r := depth(node.Right)
4
    ans = max(ans, l+r)  // 更新直径
5
    return max(l, r) + 1 // 返回深度
6
}

核心破题点：直径不一定过根节点，每个节点都要算

0872. 叶子相似的树 `Easy`

1
func find(cur *TreeNode) {
2
    if cur == nil { return }
3
    if cur.Left == nil && cur.Right == nil { leaf = append(leaf, cur.Val); return }
4
    find(cur.Left); find(cur.Right)
5
}

1161. 最大层内元素和 `Medium`

题意：给定一棵二叉树，返回「层内节点值之和最大」的那一层的层号（root 是第 0 层）。若有多个层的和相同且都是最大，返回最小的层号。

核心思路：BFS 层序遍历，每弹出一整层时把该层所有节点值求和，记录最大值及其层号。

1
func maxLevelSum(root *TreeNode) int {
2
    q := []*TreeNode{root}
3
    bestLevel, bestSum := 0, root.Val
4
    level := 0
5
    for len(q) > 0 {
6
        size := len(q)
7
        sum := 0
8
        for i := 0; i < size; i++ { // 一次性处理当前层
9
            node := q[0]; q = q[1:]
10
            sum += node.Val
11
            if node.Left != nil { q = append(q, node.Left) }
12
            if node.Right != nil { q = append(q, node.Right) }
13
        }
14
        if sum > bestSum { bestSum = sum; bestLevel = level } // 用 > 保证并列取最小层号
15
        level++
16
    }
17
    return bestLevel
18
}

例子树：

1
      1          (层0, 和=1)
2
     / \
3
    7   0        (层1, 和=7)
4
   / \
5
  7  -8          (层2, 和=7-8=-1)

层0=1，层1=7，层2=-1 → 最大层内和为 7，出现在层 1，返回 1。

核心破题点：BFS 按层处理，size 控制「一次只取一整层」再求和
避坑指南：比较用严格 > 而非 >=，并列时才返回最小层号；初始 bestSum 要设为第 0 层的值而非 0（否则全负数会错）

1372. 二叉树中的最长交错路径 `Medium`

核心思路：DFS 记录方向和长度，同方向重置为 1，交替方向 +1。

1
func dfs(node *TreeNode, toLeft bool, length int) {
2
    if node == nil { return }
3
    ans = max(ans, length)
4
    if toLeft {
5
        dfs(node.Right, false, length+1)  // 交替
6
        dfs(node.Left, true, 1)           // 同方向重置
7
    } else {
8
        dfs(node.Left, true, length+1)
9
        dfs(node.Right, false, 1)
10
    }
11
}

1448. 统计二叉树中好节点的数目 `Medium`

题意：从根到该节点路径上没有比它更大的值则为好节点，统计好节点总数。

1
func dfs(node *TreeNode, curmax int) {
2
    if node == nil { return }
3
    if node.Val >= curmax { curmax = node.Val; ans++ }  // >= 等值也是好节点
4
    dfs(node.Left, curmax); dfs(node.Right, curmax)
5
}

八、图与 BFS/DFS

图题万能套路：建邻接表 → DFS/BFS 遍历 → visited 数组防重复

0200. 岛屿数量 `Medium`

核心思路：遍历网格，遇到 ‘1’ 计数 +1，DFS 把连通的陆地全改成 ‘0’（沉岛法）。

1
func find(r, c int) {
2
    if r < 0 || r >= m || c < 0 || c >= n || grid[r][c] == '0' { return }
3
    grid[r][c] = '0'  // 沉岛
4
    find(r-1, c); find(r+1, c); find(r, c-1); find(r, c+1)
5
}
6
// 主循环
7
if grid[i][j] == '1' { ans++; find(i, j) }

核心破题点：沉岛法——原地修改网格代替 visited 数组
避坑指南：grid[r][c] = '0' 必须在四向递归之前

网格可视化（4×5 网格，2 个岛屿）：

1=陆地 0=水域

执行流程：

遍历到 (0,0)=‘1’ → ans=1，DFS 沉岛 → (0,0)(0,1)(1,1)(1,2)(2,2) 全改 ‘0’
遍历到 (2,4)=‘1’ → ans=2，DFS 沉岛 → (2,4)(3,4) 全改 ‘0’
剩余全是 ‘0’ → 结果 = 2

0207. 课程表 `Medium`

题意：共有 numCourses 门课（编号 0..n-1），prerequisites 里每项 [a, b] 表示「要修课 a 必须先修完课 b」。问：是否能按顺序修完所有课（即不存在「先修依赖环」）。

如何转换成图：每门课是一个节点，依赖关系是一条有向边。关键在边的方向——[a, b] 表示「b 是 a 的先修」，即「先有 b 才能到 a」，所以边是 b → a（从先修课指向后续课）。构建邻接表：

1
graph := make([][]int, numCourses)
2
for _, p := range prerequisites {
3
    a, b := p[0], p[1]      // 修 a 需要先修 b
4
    graph[b] = append(graph[b], a) // 边：b → a
5
}

核心思路：拓扑排序检测有向图是否有环。三色标记法：0=未访问，1=访问中，2=已完成。

1
func dfs(cur int) bool {  // 返回 true 表示有环
2
    if status[cur] == 1 { return true }   // 访问中遇到 → 有环
3
    if status[cur] == 2 { return false }  // 已完成 → 无环
4
    status[cur] = 1
5
    for _, next := range graph[cur] { if dfs(next) { return true } }
6
    status[cur] = 2
7
    return false
8
}

核心破题点：遇到「访问中」的节点说明存在环
避坑指南：status 设为 1 要在递归之前，设为 2 要在递归之后

如何建边的直观对照：

prerequisites 项	含义	有向边
`[1, 0]`	修 1 前先修 0	`0 → 1`
`[2, 1]`	修 2 前先修 1	`1 → 2`
`[3, 2]`	修 3 前先修 2	`2 → 3`
`[1, 3]`	修 1 前先修 3	`3 → 1`

执行流程（numCourses=4, prerequisites=[[1,0],[2,1],[3,2],[1,3]]）：

图结构：0→1→2→3→1（存在环 1→2→3→1）

步骤	DFS节点	status变化	邻居	结果
1	0	0→1	[1]	递归1
2	1	0→1	[2,3]	递归2
3	2	0→1	[3]	递归3
4	3	0→1	[1]	递归1
5	1	status==1!	-	⚠️ 遇到访问中 → 有环!

graph TD
    A["未访问 (0)"] -->|" 开始 DFS "| B["访问中 (1)"]
    B -->|" 遇到访问中节点 "| C["有环! 返回 false"]
    B -->|" 所有邻居完成 "| D["已完成 (2)"]
    D --> E["无环, 返回 true"]
    style C fill: #f99, color: #1a1a1a
    style E fill: #9f9, color: #1a1a1a

0547. 省份数量 `Medium`

核心思路：DFS 求连通分量数量。

1
func dfs(from int) {
2
    vis[from] = true
3
    for to, conn := range isConnected[from] {
4
        if conn == 1 && !vis[to] { dfs(to) }
5
    }
6
}
7
for i := range vis { if !vis[i] { ans++; dfs(i) } }

0841. 钥匙和房间 `Medium`

题意：有 n 个房间，编号 0..n-1。一开始只有 0 号房间是开着的。每个房间 i 里放着一串钥匙 rooms[i]（一组房间号），拿到钥匙就能打开对应的房间。问：能否从 0 出发，打开并进入所有房间？

核心思路：把「房间」当节点、「钥匙能开的房间」当出边，这本质是从 0 出发的图遍历。只要从 0 做 DFS/BFS 能覆盖全部节点，就说明能进所有房间。

1
func canVisitAllRooms(rooms [][]int) bool {
2
    n := len(rooms)
3
    visited := make([]bool, n)
4
    var dfs func(int)
5
    dfs = func(u int) {
6
        visited[u] = true
7
        for _, v := range rooms[u] { // rooms[u] 是房间 u 里钥匙能开的房间
8
            if !visited[v] { dfs(v) }
9
        }
10
    }
11
    dfs(0)
12
    for _, ok := range visited { // 检查是否每个房间都进过
13
        if !ok { return false }
14
    }
15
    return true
16
}

例子 rooms = [[1],[2],[3],[]]：

0 号房有钥匙 [1] → 打开 1
1 号房有钥匙 [2] → 打开 2
2 号房有钥匙 [3] → 打开 3
3 号房空

访问顺序 0→1→2→3，全部 4 个房间都进过 → 返回 true。

若 rooms = [[1],[2],[],[1]]（房间 0 只能到 1、1 到 2，但 3 谁也开不了）→ 漏掉房间 3 → 返回 false。

核心破题点：钥匙即邻接边，问题等价于「从 0 出发能否遍历全图」
避坑指南：visited 标记要在进入节点时设置，避免同一房间被重复入栈；别漏掉最后「是否全访问」的判定

0994. 腐烂的橘子 `Medium`

题意：网格中腐烂橘子每分钟感染上下左右四邻的新鲜橘子，求全部腐烂的最少分钟数，不可能则返回 -1。

核心思路：多源 BFS，每轮同时感染。必须先标记再统一更新，避免本轮新腐烂的继续感染。

核心破题点：多源 BFS = 所有初始腐烂橘子同时入队，逐层扩展
避坑指南：用标记数组先记录再统一更新

0649. Dota2 参议院 `Medium`

核心思路：双队列模拟。下标小的先出手，胜者下标 +n 进入下一轮。

1
for len(radiant) > 0 && len(dire) > 0 {
2
    if radiant[0] < dire[0] {
3
        radiant = append(radiant, radiant[0]+n)  // 进入下一轮
4
    } else {
5
        dire = append(dire, dire[0]+n)
6
    }
7
    radiant = radiant[1:]; dire = dire[1:]
8
}

核心破题点：用下标比较决定谁先出手，胜者加 n 入队表示进入下一轮
⚠️ 常见失败原因：仅统计 R 和 D 的数量取多数获胜，完全忽略 banning 的顺序策略。如 "DDRRR" 中 D=2<R=3 但 D 方先手连续禁令 R 方，实际 D 方获胜

3310. 移除可疑的方法 `Medium`

题意：方法 k 有 bug，需删除 k 及其直接/间接调用的所有方法。但只有当这组方法没有被外部调用时才能删除。

核心思路：①DFS 标记 k 可达的所有可疑方法 ②检查是否存在「非可疑 → 可疑」的调用边 ③无外部调用则删除，否则全部保留。

1
func remainingMethods(n int, k int, invocations [][]int) []int {
2
    graph := make([][]int, n)  // 建邻接表
3
    for _, edge := range invocations { graph[edge[0]] = append(graph[edge[0]], edge[1]) }
4

5
    isFault := make([]bool, n)  // 可疑标记
6
    var dfs func(int)
7
    dfs = func(cur int) {
8
        if isFault[cur] { return }
9
        isFault[cur] = true
10
        for _, next := range graph[cur] { dfs(next) }  // 标记所有调用链
11
    }
12
    dfs(k)  // 从 k 开始标记
13

14
    canRemove := true
15
    for _, edge := range invocations {  // 检查外部调用
16
        if !isFault[edge[0]] && isFault[edge[1]] { canRemove = false; break }  // 外部→可疑
17
    }
18

19
    var res []int
20
    if !canRemove {  // 不能删，返回全部
21
        for i := 0; i < n; i++ { res = append(res, i) }
22
    } else {  // 可以删，返回非可疑
23
        for i := 0; i < n; i++ { if !isFault[i] { res = append(res, i) } }
24
    }
25
    return res
26
}

运行示例：n=5, k=0, invocations=[[1,2],[0,2],[0,1],[3,4]]

1
调用图：0→2, 0→1, 1→2, 3→4
2
可疑集合（从0可达）：{0, 1, 2}
3
检查外部调用：3→4（3非可疑，4非可疑）→ 无外部→可疑的边
4
可以删除！返回 [3, 4]

graph TD
    A["DFS 从 k 出发
标记可疑集合"] --> B["遍历所有调用边"]
    B --> C{"存在 非可疑→可疑 的边?"}
    C -->|是| D["不能删除
返回全部方法"]
    C -->|否| E["可以删除
返回非可疑方法"]
    style D fill: #ffcdd2, color: #1a1a1a
    style E fill: #c8e6c9, color: #1a1a1a

核心破题点：不是有环就不能删，而是有「外部节点调用可疑节点」就不能删
避坑指南：DFS 标记和外部调用检查是两个独立步骤，缺一不可

九、动态规划

DP 解题四步走：①定义状态 ②写转移方程 ③初始化 ④确定遍历顺序

0005. 最长回文子串 `Medium`

核心思路：中心扩展法。每个位置分奇偶两种情况向外扩展。

1
for i := 0; i < n; i++ {
2
    // aba 型（奇数长度）
3
    for l, r := i-1, i+1; l >= 0 && r < n && s[l] == s[r]; l, r = l-1, r+1 {}
4
    // abba 型（偶数长度）
5
    for l, r := i, i+1; l >= 0 && r < n && s[l] == s[r]; l, r = l-1, r+1 {}
6
}

核心破题点：回文中心可能是 1 个字符（奇）或 2 个字符（偶）

0042. 接雨水 `Hard`（DP 解法）

核心思路：位置 i 的雨水量 = min(左边最高墙, 右边最高墙) - height[i]。先预处理出每个位置左侧、右侧的最大值数组，再逐个位置求和。

1
n := len(height)
2
// 1. 预处理：每个位置左侧（含自己）的最大高度
3
leftMax := make([]int, n)
4
leftMax[0] = height[0]
5
for i := 1; i < n; i++ { leftMax[i] = max(leftMax[i-1], height[i]) }
6
// 2. 预处理：每个位置右侧（含自己）的最大高度
7
rightMax := make([]int, n)
8
rightMax[n-1] = height[n-1]
9
for i := n-2; i >= 0; i-- { rightMax[i] = max(rightMax[i+1], height[i]) }
10
// 3. 累加每个位置能接的雨水
11
res := 0
12
for i := 0; i < n; i++ { res += max(0, min(leftMax[i], rightMax[i]) - height[i]) }

运行示例（height = [0,1,0,2,1,0,1,3,2,1,2,1]）：

i	height	leftMax	rightMax	min(l,r)	雨水 = min-height
0	0	0	3	0	0
1	1	1	3	1	0
2	0	1	3	1	1
3	2	2	3	2	0
4	1	2	3	2	1
5	0	2	3	2	2
6	1	2	3	2	1
7	3	3	3	3	0
8	2	3	2	2	0
9	1	3	2	2	1
10	2	3	2	2	0
11	1	3	1	1	0

总雨水 = 1+1+2+1+1 = 6（位置 8、10、11 的 rightMax 比 leftMax 小，体现「右侧矮」）

时间 O(n)，空间 O(n)；也可用双指针 O(1) 空间（见双指针章节）

0045. 跳跃游戏 II `Medium`

题意：数组每个元素表示最大跳跃步数，求到末尾的最少跳跃次数。

核心思路：贪心 + BFS 层次思想。维护当前跳跃边界和最远可达。

1
for i := 0; i < n; i++ {
2
    pos = max(pos, nums[i]+i)
3
    if i == end { end = pos; ans++; if end >= n-1 { break } }
4
}

核心破题点：把跳跃看作 BFS 的层次遍历，到达边界就跳一步
⚠️ 常见失败原因：当 n=1（只有一个元素）时，i==end 立即触发 ans++ 返回 1，但正确答案是 0（已在终点无需跳跃）。应加 if n == 1 { return 0 } 特判

0053. 最大子数组和 `Medium`

题意：找连续子数组使其和最大，返回最大和。

核心思路：dp[i] = max(nums[i], dp[i-1]+nums[i])，前缀和为负就抛弃。

1
res := nums[0]
2
for i := 1; i < n; i++ {
3
    if nums[i-1] > 0 { nums[i] += nums[i-1] }  // 原地 DP
4
    res = max(res, nums[i])
5
}

核心破题点：以 i 结尾的最大和 = max(自己, 自己 + 前面最大和)
避坑指南：res 初始为 nums[0] 而非 0（数组可能全负）

执行流程（nums = [-2,1,-3,4,-1,2,1,-5,4]）：

i	nums[i]原始	前面和>0?	nums[i]更新后	res
0	-2	-	-2	-2
1	1	-2≤0, 不加	1	1
2	-3	1>0, 加	1+(-3)=-2	1
3	4	-2≤0, 不加	4	4
4	-1	4>0, 加	4+(-1)=3	4
5	2	3>0, 加	3+2=5	5
6	1	5>0, 加	5+1=6	6 ✓max
7	-5	6>0, 加	6+(-5)=1	6
8	4	1>0, 加	1+4=5	6

结果 = 6（子数组 [4,-1,2,1]）。前缀和为正就延续，为负就从头开始

0062. 不同路径 `Medium`

题意：m×n 网格从左上到右下有多少条路径，只能向右或向下走。

1
for i := 0; i < m; i++ { dp[i][0] = 1 }
2
for j := 0; j < n; j++ { dp[0][j] = 1 }
3
for i := 1; i < m; i++ {
4
    for j := 1; j < n; j++ { dp[i][j] = dp[i-1][j] + dp[i][j-1] }
5
}

核心破题点：首行首列只有一条路径

0064. 最小路径和 `Medium`

题意：m×n 网格从左上到右下的路径最小和，只能向右或向下走。

1
// 原地修改
2
for i := 1; i < m; i++ { grid[i][0] += grid[i-1][0] }
3
for j := 1; j < n; j++ { grid[0][j] += grid[0][j-1] }
4
for i := 1; i < m; i++ {
5
    for j := 1; j < n; j++ { grid[i][j] += min(grid[i-1][j], grid[i][j-1]) }
6
}

0070. 爬楼梯 `Easy`

题意：每次爬 1 或 2 阶，爬到第 n 阶有多少种方法。

1
p, q := 1, 2  // f(1)=1, f(2)=2
2
for i := 3; i <= n; i++ { p, q = q, p+q }
3
return q

核心破题点：本质是斐波那契，用滚动变量省空间

0072. 编辑距离 `Medium`

题意：将 word1 变成 word2 的最少操作次数（插入/删除/替换一个字符）。

核心思路：dp[i][j] = word1 前 i 个变成 word2 前 j 个的最少操作数。

1
// 初始化: dp[i][0]=i, dp[0][j]=j
2
if word1[i-1] == word2[j-1] { dp[i][j] = dp[i-1][j-1] }  // 相同不用操作
3
else { dp[i][j] = min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]) + 1 }  // 删/插/替换

核心破题点：dp 维度是 (m+1)×(n+1)，第 0 行/列表示空串
避坑指南：不要用 m×n 的 dp 数组，边界处理会出错

DP 状态表（word1=“horse”, word2=“ros”）：

	∅	r	o	s
∅	0	1	2	3
h	1	1 (替换h→r)	2	3
o	2	2	1 (o==o,继承)	2
r	3	2 (r==r,继承)	2	3
s	4	3	3	2 (s==s,继承)
e	5	4	4	3 (删除e)

绿色 = 字符相同直接继承；黄色 = 替换操作；红色 = 最终答案。结果 = 3（horse → rorse → rose → ros）

graph TD
    A["word1[i-1] == word2[j-1]"] -->|是| B["dp[i][j] = dp[i-1][j-1]"]
    A -->|否| C["三种操作取最小+1"]
    C --> D["删: dp[i-1][j] + 1"]
    C --> E["插: dp[i][j-1] + 1"]
    C --> F["替换: dp[i-1][j-1] + 1"]

⚠️ 常见失败原因：第一行/列初始化用 mark 累加器，找到匹配字符后就不再递增，导致后续删除/插入代价被忽略。应直接令 dp[i][0]=i, dp[0][j]=j

0097. 交错字符串 `Medium`

题意：判断 s3 是否由 s1 和 s2 交错组成（保持各字符串内部相对顺序）。

核心思路：dp[i][j] = s1 前 i 个和 s2 前 j 个能否交错组成 s3 前 i+j 个。

1
if s1[i-1] == s3[i+j-1] { dp[i][j] = dp[i-1][j] }
2
if s2[j-1] == s3[i+j-1] { dp[i][j] = dp[i][j] || dp[i][j-1] }  // 注意 ||

核心破题点：最后一步来自 s1 还是 s2，两种情况是「或」关系

0118. 杨辉三角 `Easy`

1
ans[i][0], ans[i][i] = 1, 1
2
for j := 1; j < i; j++ { ans[i][j] = ans[i-1][j] + ans[i-1][j-1] }

0121. 买卖股票的最佳时机 `Easy`

题意：只能买卖一次，求最大利润。

1
minPrice := math.MaxInt32; ans := 0
2
for _, p := range prices {
3
    minPrice = min(minPrice, p)
4
    ans = max(ans, p - minPrice)
5
}

核心破题点：维护前缀最小值，每天尝试卖出

0139. 单词拆分 `Medium`

题意：判断字符串 s 能否由字典 wordDict 中的单词拼接而成。

1
dp := make([]bool, n+1); dp[0] = true
2
for i := 1; i <= n; i++ {
3
    for _, word := range wordDict {
4
        l := len(word)
5
        if l <= i && dp[i-l] && s[i-l:i] == word { dp[i] = true; break }
6
    }
7
}

核心破题点：dp[0] = true 是递推起点

0152. 乘积最大子数组 `Medium`

核心思路：同时维护最大值和最小值（负数 × 负数 = 正数）。

1
mem[i] = max(mem[i-1]*nums[i], nums[i], mim[i-1]*nums[i])  // 最大
2
mim[i] = min(mem[i-1]*nums[i], nums[i], mim[i-1]*nums[i])  // 最小
3
ans = max(ans, mem[i])

核心破题点：负数让最小变最大，所以必须同时维护 max 和 min
避坑指南：ans 初始为 nums[0]
⚠️ 常见失败原因：ans 初始化为 -10 而非 nums[0]，当数组长度为 1 时循环不执行，直接返回 -10。即使数组更长，若 nums[0] 是最大乘积也会返回错误值

0198. 打家劫舍 `Medium`

题意：相邻房屋不能同时偷，求能偷到的最大金额。

1
prev2 := nums[0]; prev1 := max(nums[0], nums[1])
2
for i := 2; i < n; i++ {
3
    current := max(prev2+nums[i], prev1)  // 偷 or 不偷
4
    prev2 = prev1; prev1 = current
5
}

核心破题点：偷当前家 + 前 i-2 的收益，或不偷取前 i-1 的收益
避坑指南：prev1 初始是 max(nums[0], nums[1]) 不是 nums[1]

执行流程（nums = [2,7,9,3,1]）：

i	nums[i]	偷(i): prev2+nums[i]	不偷(i): prev1	current	说明
0	2	-	-	2	初始 prev2
1	7	-	-	7	prev1=max(2,7)
2	9	2+9=11	7	11	偷2+9 > 不偷7
3	3	7+3=10	11	11	不偷(11) > 偷(10)
4	1	11+1=12	11	12	偷11+1 > 不偷11

结果 = 12（偷第0,2,4家：2+9+1=12）

⚠️ 常见失败原因：prev1 初始化为 nums[1] 而非 max(nums[0], nums[1])，当 nums[0] > nums[1] 时（如 [2,1,1,2] ）取了较小值导致后续全错

0279. 完全平方数 `Medium`

题意：给你一个正整数 n，问最少需要多少个完全平方数（1, 4, 9, 16, …）相加能得到 n。（如 n=12 → 4+4+4 用 3 个；n=13 → 4+9 用 2 个）

如何转为完全背包：把每个完全平方数 j*j 看成一种「硬币」，面值就是 j*j；n 看成要凑的「金额」。因为同一个平方数可以用任意多次（比如 12 用了三次 4），这正是完全背包（硬币可无限取）。目标是「用最少的硬币数」凑出金额 n。

dp[i] = 凑出金额 i 最少需要的完全平方数个数
转移：对每个可用平方数 j*j ≤ i，dp[i] = min(dp[i], dp[i - j*j] + 1)
为什么是完全背包：外层 i 从小到大、内层枚举平方数，计算 dp[i] 时 dp[i - j*j] 已经包含「用过该平方数」的情况，于是同一平方数可重复累加 → 等价于硬币无限取。若改成内层 i 逆序就是 0-1 背包（每种只能用一次）。

1
dp := make([]int, n+1); dp[0] = 0
2
for i := 1; i <= n; i++ {
3
    dp[i] = n  // 初始化为最大值（最坏每个 1 累加）
4
    for j := 1; j*j <= i; j++ { dp[i] = min(dp[i], dp[i-j*j]+1) }
5
}

例子 n = 12：

dp[4] = 1（用一个 4）；dp[8] = 2（4+4）；dp[12] = min(..., dp[12-4]+1=dp[8]+1=3) → 3 个（4+4+4）。dp[12]=3。
核心破题点：完全平方数 = 可无限使用的硬币，目标是「最少个数」→ 完全背包求最小值
避坑指南：dp[0]=0 是基石（金额 0 需 0 个硬币）；初始化 dp[i] 用足够大的值（如 n）而非 0，否则 min 永远取 0

0300. 最长递增子序列 `Medium`

题意：找最长严格递增子序列的长度。

1
dp[i] = 1  // 初始化
2
for j := 0; j < i; j++ {
3
    if nums[i] > nums[j] { dp[i] = max(dp[i], dp[j]+1) }
4
}
5
ans = max(dp...)  // 答案是 dp 数组最大值，不是 dp[n-1]

核心破题点：dp[i] 定义为「以 nums[i] 结尾」的 LIS，不是「前 i 个」
避坑指南：答案是 dp 数组最大值；进阶用二分 + 贪心做到 O(n log n)

执行流程（nums = [10,9,2,5,3,7,101,18]）：

i	nums[i]	检查所有 j<i	dp[i]	说明
0	10	无	1	初始
1	9	9<10 跳过	1	没有比9小的前驱
2	2	2<10, 2<9 跳过	1	没有比2小的前驱
3	5	5>2→dp[2]+1=2	2	[2,5]
4	3	3>2→dp[2]+1=2	2	[2,3]
5	7	7>2→2, 7>5→3, 7>3→3	3	[2,5,7]或[2,3,7]
6	101	101>所有→取dp[5]+1=4	4	[2,5,7,101]
7	18	18>2→2, 18>5→3, 18>3→3, 18>7→4	4	[2,5,7,18]

结果 = 4（LIS = [2,5,7,101] 或 [2,5,7,18]）

0322. 零钱兑换 `Medium`

题意：给定不同面额的硬币 coins 和一个总金额 amount，计算凑成总金额所需的最少硬币个数。每种硬币可以无限次使用。若无法凑出则返回 -1。

如何转为完全背包：把 coins 看作「物品」，每个物品有重量=面值、价值=1（用一个硬币计 1 次）；amount 是「背包容量」。因为每种硬币能用任意多次，这正是完全背包。目标是「装满容量为 amount 的背包，最少价值（最少硬币数）」。

dp[i] = 凑出金额 i 的最少硬币数
转移：dp[i] = min(dp[i], dp[i - coin] + 1)，对每个 coin ≤ i
为什么是完全背包：外层 i 从小到大遍历金额，计算 dp[i] 时 dp[i-coin] 已含「用过多枚该 coin」的状态，所以同一面额可重复取 → 硬币无限用。若内层 i 改成逆序，就成了 0-1 背包（每种硬币仅一次）。

1
dp := make([]int, amount+1); dp[0] = 0
2
for i := 1; i <= amount; i++ {
3
    dp[i] = amount + 1  // 不可达标记（比最大可能硬币数还多）
4
    for _, coin := range coins {
5
        if coin <= i { dp[i] = min(dp[i], dp[i-coin]+1) }
6
    }
7
}
8
if dp[amount] > amount { return -1 } // 仍不可达 → 凑不出

例子 coins = [1,2,5], amount = 11：

dp[5]=1（一个 5）；dp[10]=2（两个 5）；dp[11] = min(..., dp[11-1]+1=dp[10]+1=3, dp[11-5]+1=dp[6]+1=...) → 最少 3 个（5+5+1 或 5+2+2+2? 那是4，所以取 5+5+1=3）。dp[11]=3。
核心破题点：完全背包，每个硬币可无限使用，求最少个数 → dp 取 min
避坑指南：不可达时返回 -1（用 amount+1 做哨兵）；初始化值不能太大以免 +1 溢出；求「最少」用 min、求「最多」才用 max

0416. 分割等和子集 `Medium`

题意：能否把一个数组 nums 分成两个子集，使两个子集的元素之和相等。

如何转为 0-1 背包：

先判总和 sum：若 sum 为奇数，根本无法平分 → 直接 false；否则目标 target = sum/2。
问题变成：能否从数组中选出若干个数，使它们的和恰好等于 target。这正是 0-1 背包——每个数是「一件物品」，重量=数值、价值=数值；背包容量=target；问能否恰好装满。每个数只能用一次（0-1 背包核心）。
dp[j] 表示「能否凑出和为 j」。对当前数 num，要么不选（dp[j] 不变），要么选（dp[j-num] 为真则 dp[j] 变真）：dp[j] = dp[j] || dp[j-num]。

为什么内层要逆序（从 target 倒着到 num）：

若正序遍历 j，计算 dp[j] 时用到的 dp[j-num] 已经是本轮刚更新过的值（已经把当前 num 算进去了），于是同一个 num 会被反复累加 → 退化成「完全背包」（每种数能用无限次），错误。
逆序遍历能保证 dp[j-num] 仍是上一轮（还没考虑当前 num）的状态，从而保证每个 num 在本轮最多参与一次选择 → 正确的 0-1 背包。

1
target := sum / 2
2
dp := make([]bool, target+1); dp[0] = true  // 和为 0 必然可达
3
for _, num := range nums {
4
    for j := target; j >= num; j-- {  // 逆序！保证每个数只用一次
5
        dp[j] = dp[j] || dp[j-num]
6
    }
7
    if dp[target] { return true }  // 提前命中可剪枝
8
}

例子 nums = [1,5,11,5]，sum=22，target=11：

处理 1：dp[1]=true
处理 5：dp[5]=true, dp[6]=true（1+5）
处理 11：dp[11]=true → 找到和为 11 的子集（单个 11）→ 返回 true（另一半 [1,5,5] 和也是 11）
核心破题点：等和分割 = 能否用 0-1 背包「恰好凑出 sum/2」
避坑指南：sum 为奇数直接 false；内层必须逆序防重复选同一元素；dp[0]=true 是初始化基石

0746. 使用最小花费爬楼梯 `Easy`

1
dp := make([]int, n+1)  // dp[0]=dp[1]=0
2
for i := 2; i <= n; i++ { dp[i] = min(dp[i-1]+cost[i-1], dp[i-2]+cost[i-2]) }

核心破题点：dp 长度 n+1，楼顶在数组之后一位

1137. 第 N 个泰波那契数 `Easy`

1
t0, t1, t2 := 0, 1, 1
2
for i := 3; i <= n; i++ { t0, t1, t2 = t1, t2, t0+t1+t2 }
3
return t2

⚠️ 常见失败原因：当 n=0/1/2 时循环条件 i:=3; i<=n 不满足，ans 保持初始值 0 被返回。但 T(1)=1, T(2)=1 ，需特判或正确初始化基例

1143. 最长公共子序列 `Medium`

1
// dp[i][j] = text1 前 i 个与 text2 前 j 个的 LCS
2
if text1[i-1] == text2[j-1] { dp[i][j] = dp[i-1][j-1] + 1 }
3
else { dp[i][j] = max(dp[i-1][j], dp[i][j-1]) }

核心破题点：相同取对角线 +1，不同取上/左最大值
⚠️ 常见失败原因：匹配时用 max(dp[i+1][j], dp[i][j+1], dp[i+1][j+1]) + 1 而非 dp[i+1][j+1] + 1 ，导致重复计数——同一个字符被算了两次

十、回溯

回溯万能模板：做选择 → 递归 → 撤销选择

1
func backtrack(路径, 选择列表) {
2
    if 满足结束条件 { 结果.add(路径的拷贝); return }
3
    for 选择 in 选择列表 {
4
        做选择
5
        backtrack(路径, 选择列表)
6
        撤销选择
7
    }
8
}

0017. 电话号码的字母组合 `Medium`

1
maps := map[string]string{"2":"abc","3":"def",...}
2
fun = func(idx int) {
3
    if idx == len(digits) { ans = append(ans, tmp); return }
4
    for _, ch := range maps[string(digits[idx])] {
5
        tmp += string(ch); fun(idx+1); tmp = tmp[:len(tmp)-1]  // 回溯
6
    }
7
}

0022. 括号生成 `Medium`

核心思路：左括号数 >= 右括号数，剩余数相等时只能加左括号。

1
fun = func(left, right int, tmp string) {
2
    if right == 0 { ans = append(ans, tmp); return }
3
    if left == right { fun(left-1, right, tmp+"(") }       // 只能加左
4
    else {
5
        if left > 0 { fun(left-1, right, tmp+"(") }        // 可以加左
6
        fun(left, right-1, tmp+")")                         // 可以加右
7
    }
8
}

核心破题点：合法括号序列中任意前缀左括号数 >= 右括号数

0039. 组合总和 `Medium`

核心思路：选/不选模式。选了可以继续选同一个（可重复），不选跳到下一个。

1
if rest-num >= 0 {
2
    tem = append(tem, num)
3
    if rest-num == 0 { ans = append(ans, append([]int{}, tem...)) }
4
    else { find(cand, rest-num) }  // 继续选当前
5
    tem = tem[:len(tem)-1]          // 回溯
6
}
7
find(cand[1:], rest)  // 不选当前

核心破题点：选了之后递归仍传 cand（而非 cand[1:]）实现重复选取
避坑指南：保存结果必须深拷贝

回溯树（candidates = [2,3,6,7], target = 7）：

graph TD
    R["rest=7"] --> A2["选2 rest=5"]
    R --> A3["选3 rest=4"]
    R --> A6["选6 rest=1"]
    R --> A7["选7 rest=0 ✅ [7]"]
    A2 --> B2["选2 rest=3"]
    A2 --> B3["选3 rest=2"]
    A2 --> B6["选6 rest=-1 ✂剪枝"]
    B2 --> C2["选2 rest=1"]
    B2 --> C3["选3 rest=0 ✅ [2,2,3]"]
    C2 --> D2["选2 rest=-1 ✂剪枝"]
    C2 --> D3["选3 rest=-2 ✂剪枝"]
    A3 --> E3["选3 rest=1"]
    E3 --> F3["选3 rest=-2 ✂剪枝"]
    E3 --> F6["选6 rest=-5 ✂剪枝"]
    style A7 fill: #c8e6c9, color: #1a1a1a
    style C3 fill: #c8e6c9, color: #1a1a1a

绿色 = 找到有效组合。结果 = [[7], [2,2,3]]

0046. 全排列 `Medium`

题意：给定无重复数字 nums = [1,2,3]，返回所有全排列。

核心思路：回溯——选一个未使用的数字放入 path，递归到底后撤销选择。

1
for i, b := range onPath {
2
    if !b {
3
        path = append(path, nums[i]); onPath[i] = true
4
        t()  // 递归
5
        onPath[i] = false; path = path[:len(path)-1]  // 回溯
6
    }
7
}

核心破题点：onPath 布尔数组标记已选元素，回溯时撤销
避坑指南：path = path[:len(path)-1] 回溯弹出，不能遗漏

回溯决策树（nums = [1,2,3]）：

graph TD
    R["开始 path=[]"] --> A1["选1 path=[1]"]
    R --> A2["选2 path=[2]"]
    R --> A3["选3 path=[3]"]
    A1 --> B1["选2 path=[1,2]"]
    A1 --> B2["选3 path=[1,3]"]
    A2 --> B3["选1 path=[2,1]"]
    A2 --> B4["选3 path=[2,3]"]
    A3 --> B5["选1 path=[3,1]"]
    A3 --> B6["选2 path=[3,2]"]
    B1 --> C1["选3 path=[1,2,3] ✅"]
    B2 --> C2["选2 path=[1,3,2] ✅"]
    B3 --> C3["选3 path=[2,1,3] ✅"]
    B4 --> C4["选1 path=[2,3,1] ✅"]
    B5 --> C5["选2 path=[3,1,2] ✅"]
    B6 --> C6["选1 path=[3,2,1] ✅"]
    style C1 fill: #c8e6c9, color: #1a1a1a
    style C2 fill: #c8e6c9, color: #1a1a1a
    style C3 fill: #c8e6c9, color: #1a1a1a
    style C4 fill: #c8e6c9, color: #1a1a1a
    style C5 fill: #c8e6c9, color: #1a1a1a
    style C6 fill: #c8e6c9, color: #1a1a1a

每层选一个未用过的数字，到达叶子节点即一个完整排列。共 3!=6 种。

0051. N 皇后 `Hard`

核心思路：逐行放置，用三个数组标记列和对角线。

1
if !col[i] && !diag1[idx-i+n-1] && !diag2[idx+i] {
2
    col[i], diag1[idx-i+n-1], diag2[idx+i] = true, true, true
3
    find(idx + 1)  // 递归下一行
4
    col[i], diag1[idx-i+n-1], diag2[idx+i] = false, false, false  // 回溯
5
}

核心破题点：用 row-col 和 row+col 标识两条对角线
避坑指南：主对角线索引 +n-1 偏移避免负数

对角线标记示意（N=4，放置在第0行第1列）：

1
行col: 0  1  2  3
2
  0:   .  Q  .  .     ← 放置(0,1)
3
  1:   x  .  .  x     ← diag1标记 / diag2标记
4
  2:   .  x  .  .
5
  3:   .  .  x  .

标记类型	公式	(0,1)的值	被标记的位置
列 col	col=1	1	(0,1)(1,1)(2,1)(3,1)
主对角线 diag1	row-col+n-1	0-1+3=2	(0,1)(1,2)(2,3)
副对角线 diag2	row+col	0+1=1	(0,1)(1,0)

同一条主对角线上 row-col 相同；同一条副对角线上 row+col 相同。+n-1 避免负索引

0078. 子集 `Medium`

题意：返回不含重复元素的整数数组的所有子集（幂集）。

核心思路：每个元素选/不选，到达末尾保存结果。

1
dfs = func(cur int) {
2
    if cur == len(nums) { ans = append(ans, append([]int(nil), set...)); return }
3
    set = append(set, nums[cur]); dfs(cur+1)        // 选
4
    set = set[:len(set)-1]; dfs(cur+1)               // 不选
5
}

0079. 单词搜索 `Medium`

题意：在 m×n 字符网格中搜索单词是否存在，相邻格子上下左右连通，同一格不能重复使用。

核心思路：DFS + 原地标记。把当前格子改为 ’#’ 防重复使用，递归后恢复。

1
temp := board[m][n]; board[m][n] = '#'  // 标记
2
res := dfs(m+1,n,idx+1) || dfs(m,n+1,idx+1) || dfs(m-1,n,idx+1) || dfs(m,n-1,idx+1)
3
board[m][n] = temp  // 恢复

核心破题点：原地标记代替 visited 数组

0131. 分割回文串 `Medium`

题意：将字符串分成若干子串使每个都是回文串，返回所有分割方案。

核心思路：枚举切分点，只有回文子串才递归。

1
for i := idx+1; i <= n; i++ {
2
    if isPalindrome(s[idx:i]) {
3
        res = append(res, s[idx:i])
4
        sub(i)                          // 递归
5
        res = res[:len(res)-1]          // 回溯
6
    }
7
}

0216. 组合总和 III `Medium`

题意：找出所有「和为 n、且恰好由 k 个不同数字组成」的组合，数字只能从 1..9 里取且每个最多用一次。返回所有满足条件的组合。如 k=3, n=7 → [[1,2,4]]（1+2+4=7）。

回溯思路（标准的「选 / 不选」两种分支）：

start：当前正在考虑的数字（从 start 到 9，避免重复组合、保证递增）。
target：还差多少和才凑到 n。
path：已选的数字；k - len(path) 是「还需要选几个」。
两种递归分支：
- 不选 start：dfs(start+1, target)（往后看更大的数字）。
- 选 start：path 加入 start，dfs(start+1, target-start)（和减去 start），返回后撤销选择 path = path[:len(path)-1]。
剪枝：start > 9（数字用尽）或 target < 0（和超了）直接返回；当还需选的个数 = 0 时，若 target == 0 说明凑齐，记录答案。

1
dfs = func(start, target int) {
2
    if k-len(path) == 0 { if target == 0 { ans = append(ans, copy(path)) }; return }
3
    if start > 9 || target < 0 { return }  // 剪枝
4
    dfs(start+1, target)                    // 不选 start
5
    path = append(path, start); dfs(start+1, target-start); path = path[:len(path)-1]  // 选 start + 回溯
6
}

例子 k=3, n=7 的部分搜索树（path | target）：

1
start=1: 不选 → (1,7)
2
         选1  → path=[1] target=6
3
               start=2: 选2 → [1,2] target=4
4
                         start=3: 选3 → [1,2,3] target=1 → 还需0个但target≠0 丢弃
5
                         start=4: 选4 → [1,2,4] target=0 → 还需0个且target=0 ✅ 记录

核心破题点：每个数字「选/不选」两分支回溯；start 递增避免重复组合
避坑指南：记录答案要 copy(path) 而非 path（否则后续回溯会改掉已存结果）；剪枝条件 target<0 别漏

十一、贪心

0031. 下一个排列 `Medium`

题意：找数组的下一个字典序排列（比当前大的最小排列），原地修改，已是最大则升序排列。

核心思路：从后往前找第一个降序位置 cur，再从后往前找第一个大于 nums[cur] 的交换，最后反转 cur 之后的部分。

1
// 1. 从后往前找第一个非降序位置
2
cur := n-1; for cur > 0 && nums[cur] <= nums[cur-1] { cur-- }; cur--
3
// 2. 找比 nums[cur] 大的最小值交换
4
if cur >= 0 { m := n-1; for nums[cur] >= nums[m] { m-- }; nums[cur], nums[m] = nums[m], nums[cur] }
5
// 3. 反转 cur 之后
6
reverse(nums[cur+1:])

核心破题点：从后往前找第一个可以变大的位置
⚠️ 常见失败原因：找到位置后直接交换 nums[cur] 和 nums[pre]，但正确做法是在 pre 之后的降序后缀中找到大于 nums[pre] 的最小元素交换，再反转后缀。如 [1,3,2] 期望 [2,1,3]，错误代码输出 [3,1,2]

0055. 跳跃游戏 `Medium`

题意：数组每个元素表示该位置最大跳跃步数，判断能否到达最后一个位置。

1
m := 0
2
for i := 0; i <= m; i++ {  // 只在可达范围内遍历
3
    m = max(m, i+nums[i])
4
    if m >= n-1 { return true }
5
}
6
return false

核心破题点：循环条件 i <= m，只在能到达的范围内走

0135. 分发糖果 `Hard`

题意：每个孩子至少 1 颗糖，评分高的孩子比相邻孩子糖多，求最少糖果总数。

核心思路：两次遍历——左到右保证右边大的糖果多，右到左保证左边大的糖果多，取 max。

1
// 左到右
2
if ratings[i] > ratings[i-1] { left[i] = left[i-1] + 1 } else { left[i] = 1 }
3
// 右到左
4
if ratings[i] > ratings[i+1] { right[i] = right[i+1] + 1 } else { right[i] = 1 }
5
// 取 max
6
ans = sum(max(left[i], right[i]))

核心破题点：一次遍历无法同时满足左右约束，拆成两次单向再取 max
避坑指南：右到左遍历时 i 从 n-2 到 0，不要搞反方向

执行流程（ratings = [1,0,2]）：

下标	ratings	左→右 left[]	右→左 right[]	max(left,right)
0	1	1（初始）	2（0<1→right[0]=right[1]+1=2）	2
1	0	1（0<1→left[1]=1）	1（初始）	1
2	2	2（2>0→left[2]=left[1]+1=2）	1（初始）	2

总糖果 = 2+1+2 = 5（每个孩子至少1颗，相邻评分高的糖果更多）

0334. 递增的三元子序列 `Medium`

核心思路：维护最小值和次小值，出现比次小值大的就找到了。

1
i, j := math.MaxInt, math.MaxInt
2
for _, v := range nums {
3
    if v < i { i = v }
4
    else if v > i && v < j { j = v }
5
    else if v > j { return true }
6
}

核心破题点：只需维护两个值，更新 i 不影响正确性（之前已有更大的 j 前驱）

0605. 种花问题 `Easy`

题意：花床 flowerbed 用 0（空）/ 1（已种）表示，规则是任何两朵花不能种在相邻地块。问能否在不违反规则的前提下再种下 n 朵花。

1
if flowerbed[i] == 0 {
2
    leftEmpty := i == 0 || flowerbed[i-1] == 0      // 左边界或左边为空
3
    rightEmpty := i == l-1 || flowerbed[i+1] == 0    // 右边界或右边为空
4
    if leftEmpty && rightEmpty { flowerbed[i] = 1; n-- }  // 能种就种，并就地标记
5
}

核心破题点：能种就种，贪心不会比晚种差

十二、堆与优先队列

0215. 数组中的第K个最大元素 `Medium`

核心思路：快速选择——快排 partition 每次只递归一侧。

1
pivot := rand.Intn(n)
2
arr[0], arr[pivot] = arr[pivot], arr[0]
3
pivotVal := arr[0]; l, r := 1, n-1
4
for l <= r {
5
    for l <= r && arr[l] >= pivotVal { l++ }
6
    for l <= r && arr[r] <= pivotVal { r-- }
7
    if l < r { arr[l], arr[r] = arr[r], arr[l] }
8
}
9
arr[0], arr[r] = arr[r], arr[0]
10
if r == target { return arr[r] }
11
if r > target { return find(arr[:r], target) }
12
return find(arr[r+1:], target-r-1)

核心破题点：快速选择每次只递归一侧，O(n) 期望
避坑指南：递归到右半部分要更新 target 偏移量；简单题直接 sort.Slice 更快

0295. 数据流的中位数 `Hard`

核心思路：双堆——左堆（大顶堆）存较小一半，右堆（小顶堆）存较大一半。

1
// Go 没有大顶堆，用存负数模拟
2
if left.Len() == right.Len() {
3
    heap.Push(&left, -right.pushPop(num))  // 先进右堆筛最小，放左堆
4
} else {
5
    heap.Push(&right, -left.pushPop(-num))  // 先进左堆筛最大，放右堆
6
}
7
// 中位数: 左堆顶（奇数）或两堆顶平均（偶数）

核心破题点：中位数 = 较小半部分最大值与较大半部分最小值
避坑指南：Go 大顶堆用存负数模拟；pushPop 优化避免两次堆操作
⚠️ 常见失败原因：平衡逻辑只处理了 m > n（右堆过长），完全没有处理 n > m+1（左堆过长超过 1 个），连续插入较小数字时左堆无限增长导致中位数错误

graph LR
    subgraph 双堆维护中位数
        L["大顶堆 (左)
存较小一半
3,1,2"] --- R["小顶堆 (右)
存较大一半
5,7,6"]
    end
    M["中位数 = (左堆顶 + 右堆顶) / 2"]
    L --> M
    R --> M

0347. 前 K 个高频元素 `Medium`

核心思路：哈希表统计频次 + 快速选择找前 k 个。

1
mp := map[int]int{}
2
for _, num := range nums { mp[num]++ }
3
// 转为 [数字, 频次] 数组，快速选择找前 k 个

核心破题点：转化为「频次数组的第 k 大」，用快速选择避免全排序

十三、设计题

0146. LRU 缓存 `Medium`

题意：实现 O(1) 的 get 和 put 的 LRU 缓存，超容量时淘汰最久未使用的。

（见链表章节）

核心思路：哈希表 + 双向链表，虚拟头尾节点简化边界。

避坑指南：淘汰尾节点后必须从 map 中 delete

0155. 最小栈 `Medium`

题意：实现 push/pop/top/getMin 均为 O(1) 的栈。

（见栈章节）

核心思路：辅助栈同步维护最小值。

0208. 实现 Trie (前缀树) `Medium`

核心思路：每个节点有 26 个子节点指针和 isEnd 标记。

1
type Trie struct {
2
    children [26]*Trie
3
    isEnd    bool
4
}
5
// SearchPrefix 共用：遍历字符路径
6
// Search 额外检查 isEnd
7
// StartsWith 只检查路径存在

核心破题点：search 和 startsWith 的唯一区别是是否检查 isEnd

0295. 数据流的中位数 `Hard`

（见堆章节）

0933. 最近的请求次数 `Easy`

核心思路：队列，每次 ping 时从队首弹出过期请求。

1
func Ping(t int) int {
2
    q = append(q, t)
3
    for q[0] < t-3000 { q = q[1:] }  // 弹出过期
4
    return len(q)
5
}

十四、矩阵

0048. 旋转图像 `Medium`

核心思路：两次翻转——上下水平翻转 + 主对角线转置。

1
// 1. 上下翻转
2
for i := 0; i < n/2; i++ { matrix[i], matrix[n-1-i] = matrix[n-1-i], matrix[i] }
3
// 2. 主对角线转置
4
for i := 0; i < n; i++ { for j := 0; j < i; j++ { matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j] } }

核心破题点：旋转 90° = 水平翻转 + 对角线转置
避坑指南：对角线翻转只遍历下三角 j < i

旋转过程可视化（3×3 矩阵）：

原始矩阵
123
456
789
→
① 上下翻转
789
456
123
→
② 对角线转置
741
852
963

蓝=原始　橙=上下翻转后　绿=对角线转置后（最终结果：顺时针旋转90°）

0054. 螺旋矩阵 `Medium`

题意：按顺时针螺旋顺序返回 m×n 矩阵的所有元素。

核心思路：四边界收缩，按右→下→左→上遍历。

1
for left <= right && up <= bottom {
2
    // 右: left→right
3
    // 下: up+1→bottom
4
    if left < right && up < bottom {  // 防单行/单列重复
5
        // 左: right-1→left
6
        // 上: bottom-1→up+1
7
    }
8
    left++; right--; up++; bottom--
9
}

核心破题点：if left < right && up < bottom 防止只剩一行/一列时回头重复遍历
避坑指南：每次走完四条边后都要收缩边界（left++, right—, up++, bottom—）

螺旋遍历示意（3×3 矩阵）：

graph LR
    subgraph "第1圈"
        A1["(0,0)=1 →右"] --> A2["(0,1)=2 →右"] --> A3["(0,2)=3 ↓转"]
        A3 --> A4["(1,2)=6 ↓"] --> A5["(2,2)=9 ←转"]
        A5 --> A6["(2,1)=8 ←"] --> A7["(2,0)=7 ↑转"]
        A7 --> A8["(1,0)=4 ↑"]
    end
    subgraph "第2圈(单元素)"
        B1["(1,1)=5"]
    end
    style A3 fill: #ffcdd2, color: #1a1a1a
    style A5 fill: #fff9c4, color: #1a1a1a
    style A7 fill: #c8e6c9, color: #1a1a1a
    style B1 fill: #e3f2fd, color: #1a1a1a

输出顺序：1→2→3→6→9→8→7→4→5。红=右行终点，黄=下行终点，绿=左行终点，蓝=中心

边界收缩流程：

graph TD
  S["left=0, right=n-1, up=0, bottom=m-1"] --> R["→ 右: left到right"]
  R --> D["↓ 下: up+1到bottom"]
  D --> C{"left < right 且 up < bottom?"}
  C -->|是| L["← 左: right-1到left"]
  C -->|否| E["跳过（只剩一行/一列）"]
  L --> U["↑ 上: bottom-1到up+1"]
  E --> F["收缩边界"]
  U --> F
  F --> N{"left ≤ right 且 up ≤ bottom?"}
  N -->|是| R
  N -->|否| END["结束"]

⚠️ 常见失败原因：只剩一行/一列时，“从右到左”和”从下到上”仍会执行，导致元素被重复添加。如 [[1,2,3]] 结果为 [1,2,3,2] 而非 [1,2,3]。应加 if up < bottom 和 if left < right 判断

0073. 矩阵置零 `Medium`

题意：矩阵中元素为 0 则将其所在行和列全置 0，要求 O(1) 额外空间。

核心思路：用第一行第一列当标记数组，O(1) 空间。

1
// 1. 记录首行首列是否有 0
2
// 2. 用首行首列标记内部 0 的位置
3
// 3. 根据标记置零内部
4
// 4. 最后处理首行首列

核心破题点：矩阵本身的第一行第一列当标记数组
避坑指南：先记录首行首列原始状态再写标记
⚠️ 常见失败原因：最后置零时行和列的逻辑写反了——zeroline 检测的是第一行但有 0，置零时却把第一列置零；zerorow 同理。两个 for 循环的赋值目标应互换

十五、字符串

0151. 反转字符串中的单词 `Medium`

核心思路：从右往左扫描，遇到空格切分单词。

1
t := n
2
for i := n-1; i >= 0; i-- {
3
    if s[i] == ' ' {
4
        if t-i > 1 { sb.WriteString(s[i+1:t]); sb.WriteByte(' ') }
5
        t = i
6
    }
7
}
8
if t > 0 { sb.WriteString(s[:t]) }

⚠️ 常见失败原因：每个单词追加尾部空格，且首单词前可能包含前导空格，导致结果有多余空格。如 " hello world " 返回 "world hello " 而非 "world hello"

0345. 反转字符串中的元音字母 `Easy`

题意：反转字符串中的所有元音字母（aeiou，不区分大小写）。

（见双指针章节）

0443. 压缩字符串 `Medium`

核心思路：读写双指针，数字逆序写入后反转。

1
if read == n-1 || ch != chars[read+1] {
2
    chars[write] = ch; write++
3
    if num > 1 {
4
        // 数字按位逆序写入，再反转
5
    }
6
}

1071. 字符串的最大公因子 `Easy`

核心思路：str1+str2 == str2+str1 是存在公因子的充要条件，长度取 GCD。

1
if str1+str2 != str2+str1 { return "" }
2
return str1[:gcd(len(str1), len(str2))]

1657. 确定两个字符串是否接近 `Medium`

核心思路：两个充要条件——字符集相同 + 频次多重集相同。

1
if m != n { return false }
2
// 字符集必须相同
3
for k := range mp1 { if _, ok := mp2[k]; !ok { return false } }
4
// 频次排序后比较
5
slices.Sort(cnt1); slices.Sort(cnt2)

1768. 交替合并字符串 `Easy`

题意：将 word1 和 word2 交替合并，剩余部分追加到末尾。

（见双指针章节）

最后的话：算法的本质不是背代码，而是建立「特征 → 算法」的条件反射。看到有序数组就想到二分，看到连续子数组就想到滑动窗口，看到所有方案就想到回溯。多做几遍这些题，每次关注「为什么这么想」而非「代码怎么写」，自然就能快速找到思路。

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://muxiaowf.dpdns.org/blog/260809algorithm/

SQL 算法笔记

MuxiaoWF — Sun, 09 Aug 2026 00:00:00 GMT

SQL 算法笔记

通用思维套路总览

看到什么特征 → 用什么 SQL 技巧

题目特征	首选技巧	典型题目
两个表关联取数据	INNER JOIN / LEFT JOIN	175, 1068, 1378
保留左表全部行（无匹配返回 NULL）	LEFT JOIN	175, 577, 1378, 1581
同一表比较（员工 vs 经理）	SELF JOIN（自连接）	181, 570, 1731, 1978
找重复值	GROUP BY + HAVING COUNT > 1	182, 196
分组后过滤	GROUP BY + HAVING	596, 570, 1045, 1084
分组后统计	GROUP BY + COUNT/SUM/AVG	511, 1693, 1729, 2356
排名 / Top N	窗口函数 RANK / DENSE_RANK	185, 1341
累计求和 / 滑动窗口	SUM() OVER(ORDER BY ROWS BETWEEN)	1204, 1321
条件聚合（分情况统计）	SUM(IF(…)) 或 SUM(CASE WHEN)	1193, 1661, 1393
合并多个查询结果	UNION / UNION ALL	1795, 1907, 1164
找「所有」/「全部」	HAVING COUNT(DISTINCT) = 总数	1045
比较前一天/连续 N 天	SELF JOIN + DATEDIFF	197, 180, 550
无匹配也要返回	LEFT JOIN + IS NULL	577, 581, 1978
字符串模式匹配	LIKE / REGEXP	1527, 1517, 1683
列转行	UNION ALL	1795
行转列 / 拼接	GROUP_CONCAT	1484
条件赋值	CASE WHEN	610, 626, 627
日期格式化	DATE_FORMAT	1193, 1327

SQL 执行顺序（重要！）

1
FROM + JOIN     → 先确定数据源和关联
2
WHERE           → 行级过滤
3
GROUP BY        → 分组
4
HAVING          → 组级过滤
5
SELECT          → 选择列 / 聚合 / 窗口函数
6
ORDER BY        → 排序
7
LIMIT           → 截取

关键：WHERE 在 GROUP BY 之前，不能使用聚合函数；HAVING 在 GROUP BY 之后，可以使用聚合函数。

一、基础查询（WHERE / ORDER BY / LIMIT）

0595. 大的国家 `Easy`

表结构：World(name, continent, area, population, gdp)

题目：找面积 ≥ 300万或人口 ≥ 2500万的国家。

1
SELECT name, population, area
2
FROM World
3
WHERE area >= 3000000
4
   OR population >= 25000000;

执行流程：

原始 World 表	→ WHERE 过滤
Afghanistan, Asia, 652230, 38928341, …	✅ area≥300万
Albania, Europe, 28748, 2837743, …	❌ 都不满足
Algeria, Africa, 2381741, 37100000, …	✅ area≥300万
Andorra, Europe, 468, 27457, …	❌ 都不满足
India, Asia, 3287590, 1324171354, …	✅ area≥300万

核心点：WHERE 用 OR 连接两个独立条件，满足任一即可

0584. 寻找用户推荐人 `Easy`

表结构：Customer(id, name, referee_id)

题目：找推荐人不是 id=2 的客户（包括没有推荐人的）。

1
SELECT name
2
FROM Customer
3
WHERE referee_id != 2 OR referee_id IS NULL;

执行流程：

id	name	referee_id	判断	结果
1	Will	NULL	NULL != 2 → NULL（不是 true）→ 但 IS NULL → ✅	输出
2	Jane	NULL	同上 → ✅	输出
3	Alex	2	2 != 2 → false → ❌	不输出
4	Bill	3	3 != 2 → true → ✅	输出
5	Zack	1	1 != 2 → true → ✅	输出

⚠️ 关键陷阱：referee_id != 2 不会匹配 NULL！NULL 参与比较结果是 NULL（不是 true），必须用 IS NULL 单独处理

0168. 无效的推文 `Easy`

1
SELECT tweet_id
2
FROM Tweets
3
WHERE LENGTH(content) > 15;

tweet_id	content	LENGTH	结果
1	“Vote for Biden”	14	❌
2	“Let us make sure … (30字)”	30	✅

0176. 第二高的薪水 `Medium`

表结构：Employee(id, salary)

题目：找第二高的不同薪水，不存在则返回 NULL。

1
SELECT (SELECT DISTINCT salary
2
        FROM Employee
3
        ORDER BY salary DESC LIMIT 1 OFFSET 1 ) AS SecondHighestSalary;

执行流程：

1
原始 Employee 表          → DISTINCT 去重        → ORDER BY DESC    → LIMIT 1 OFFSET 1
2
┌────┬────────┐          ┌────────┐             ┌────────┐         ┌────────┐
3
│ id │ salary │          │ salary │             │ salary │         │ salary │
4
├────┼────────┤          ├────────┤             ├────────┤         ├────────┤
5
│ 1  │ 100    │          │ 100    │             │ 400    │         │ 200    │
6
│ 2  │ 200    │   →      │ 200    │     →       │ 300    │   →     │        │
7
│ 3  │ 300    │          │ 300    │             │ 200    │         │        │
8
│ 4  │ 300    │          │ 400    │             │ 100    │         │        │
9
│ 5  │ 400    │          └────────┘             └────────┘         └────────┘
10
└────┴────────┘

核心点：使用外层 SELECT (子查询) 确保无结果时返回 NULL 而非空表

0620. 有趣的电影 `Easy`

1
SELECT *
2
FROM cinema
3
WHERE description != 'boring' AND id % 2 = 1
4
ORDER BY rating DESC;

执行流程：

id	movie	description	rating	→ WHERE	→ ORDER BY rating DESC
1	War	great 3D	8.9	✅ odd + not boring	8.9
2	Science	boring	8.4	❌ boring	-
3	Irish	NOT boring	7.0	✅ odd + not boring	7.0
4	Ice Song	Fantacy	8.6	❌ even	-
5	House card	Interesting	9.1	✅ odd + not boring	9.1
6	…	…	…	…	…

二、JOIN（内连接 / 左连接 / 自连接）

JOIN 类型对比

阴影 = 结果里出现的行来自哪里：INNER JOIN 只取两圆重叠部分；LEFT JOIN 取整个左圆（含重叠），右圆只有重叠部分算进去、没匹配的位置填 NULL。

1
 INNER（内连接）              LEFT（左连接）
2
┌────┐  ┌────┐            ┌────┐  ┌────┐
3
│    │  │    │            │████│  │    │
4
│  ██│  │██  │            │████│  │██  │
5
│  ██│  │██  │            │████│  │██  │
6
│    │  │    │            │████│  │    │
7
└────┘  └────┘            └────┘  └────┘
8
 左  右    左  右            左  右    左  右
9

10
用同一组数据看结果差异（A=左表 Person，B=右表 Address，连接键 id）：
11

12
A 表（Person）              B 表（Address）
13
┌────┬──────┐              ┌────┬──────┐
14
│ id │ name │              │ id │ city │
15
├────┼──────┤              ├────┼──────┤
16
│ 1  │ Allen│              │ 2  │ NYC  │
17
│ 2  │ Bob  │              │ 3  │ Boston│
18
│ 3  │ Zack │              └────┴──────┘
19
└────┴──────┘
20

21
① INNER JOIN（内连接）——只保留 A、B 都能按 id 匹配的行
22
┌────┬──────┬──────┐
23
│ id │ name │ city │
24
├────┼──────┼──────┤
25
│ 2  │ Bob  │ NYC  │   ← A.2 = B.2 ✅
26
│ 3  │ Zack │ Boston│  ← A.3 = B.3 ✅
27
└────┴──────┴──────┘
28
（Allen 在 B 中无匹配 → 不出现）
29

30
② LEFT JOIN（左连接）——保留 A 的全部行，B 无匹配用 NULL 填充
31
┌────┬──────┬──────┐
32
│ id │ name │ city │
33
├────┼──────┼──────┤
34
│ 1  │ Allen│ NULL │   ← B 无匹配 → city 为 NULL
35
│ 2  │ Bob  │ NYC  │
36
│ 3  │ Zack │ Boston│
37
└────┴──────┴──────┘
38

39
③ 自连接（SELF JOIN）——同一张表当两张用，用别名区分角色
40
   Employee 里：员工.managerId = 经理.id（详见 0181 / 1731 / 0570）

0175. 组合两个表 `Easy`

表结构：

Person(personId, firstName, lastName)
Address(addressId, personId, city, state)

题目：报告每个人的姓名、城市和州，没有地址的也要返回。

1
SELECT p.firstName, p.lastName, a.city, a.state
2
FROM Person p
3
         LEFT JOIN Address a ON p.personId = a.personId;

执行流程：

Person 表：

personId	firstName	lastName
1	Allen	Wang
2	Bob	Alice
3	Zack	Sy

Address 表：

addressId	personId	city	state
1	2	NYC	NY
2	3	Boston	MA

LEFT JOIN 结果：

firstName	lastName	city	state
Allen	Wang	NULL	NULL
Bob	Alice	NYC	NY
Zack	Sy	Boston	MA

Allen 在 Address 表无匹配 → city 和 state 为 NULL。LEFT JOIN 保证了 Person 表全部行都保留。

0181. 超过经理收入的员工 `Easy`（自连接）

表结构：Employee(id, name, salary, managerId)

题目：找收入比经理高的员工。

1
SELECT e1.name AS Employee
2
FROM Employee e1
3
         JOIN Employee e2 ON e1.managerId = e2.id
4
WHERE e1.salary > e2.salary;

执行流程：

Employee 表（一张表充当两个角色）：

id	name	salary	managerId
1	Joe	70000	3
2	Henry	80000	4
3	Sam	60000	NULL
4	Max	90000	NULL

自连接后（e1=员工, e2=经理）：

e1.name(员工)	e1.salary	e2.name(经理)	e2.salary	e1.salary > e2.salary?
Joe	70000	Sam	60000	✅ 70000 > 60000
Henry	80000	Max	90000	❌ 80000 < 90000

最终结果：

Employee
Joe

核心点：同一张表 JOIN 自身，用不同别名区分员工和经理角色

0577. 员工奖金 `Easy`（LEFT JOIN + IS NULL）

表结构：

Employee(empId, name, supervisor, salary)
Bonus(empId, bonus)

题目：报告奖金 < 1000 或没有奖金的员工。

1
SELECT name, bonus
2
FROM Employee e
3
         LEFT JOIN Bonus b ON e.empId = b.empId
4
WHERE b.bonus < 1000
5
   OR b.bonus IS NULL;

执行流程：

Employee 表：

empId	name	supervisor	salary
1	Brad	NULL	5000
2	John	1	4000
3	Dan	1	3000
4	Thomas	1	2000

Bonus 表：

empId	bonus
2	500
3	NULL
4	2000

LEFT JOIN 后：

name	bonus	判断
Brad	NULL	IS NULL → ✅
John	500	500 < 1000 → ✅
Dan	NULL	IS NULL → ✅
Thomas	2000	2000 ≥ 1000 → ❌

最终结果：

name	bonus
Brad	NULL
John	500
Dan	NULL

⚠️ b.bonus < 1000 不匹配 NULL，必须加 OR b.bonus IS NULL

1378. 使用唯一标识码替换员工ID `Easy`

1
SELECT euni.unique_id, e.name
2
FROM Employees e
3
         LEFT JOIN EmployeeUNI euni ON e.id = euni.id;

执行流程：

Employees	EmployeeUNI	LEFT JOIN 结果
id=1, Alice	id=1, unique_id=10	unique_id=10, Alice
id=2, Bob	(无匹配)	unique_id=NULL, Bob

1068. 产品销售分析 I `Easy`（INNER JOIN）

表结构：

Sales(sale_id, product_id, year, quantity, price)
Product(product_id, product_name)

1
SELECT p.product_name, s.year, s.price
2
FROM Sales s
3
         JOIN Product p ON s.product_id = p.product_id;

执行流程：

Sales	Product	JOIN 结果
sale_id=1, product_id=100, year=2008, price=5000	product_id=100, Nokia	Nokia, 2008, 5000
sale_id=2, product_id=100, year=2009, price=5000	product_id=100, Nokia	Nokia, 2009, 5000
sale_id=7, product_id=200, year=2011, price=7000	product_id=200, Apple	Apple, 2011, 7000

1581. 进店却未进行过交易的顾客 `Easy`（LEFT JOIN + IS NULL）

表结构：

Visits(visit_id, customer_id)
Transactions(transaction_id, visit_id, amount)

1
SELECT v.customer_id, COUNT(v.customer_id) AS count_no_trans
2
FROM Visits v
3
         LEFT JOIN Transactions t ON v.visit_id = t.visit_id
4
WHERE t.transaction_id IS NULL
5
GROUP BY v.customer_id;

执行流程：

Visits	LEFT JOIN Transactions	WHERE IS NULL	GROUP BY
visit=1, customer=23	+ trans=1, amount=950	❌ 有交易	-
visit=2, customer=9	+ NULL（无交易）	✅	customer=9, count=1
visit=4, customer=30	+ NULL（无交易）	✅	customer=30, count=1
visit=5, customer=54	+ NULL（无交易）	✅	customer=54, count=2
visit=7, customer=54	+ NULL（无交易）	✅	(54 共 2 次)
visit=8, customer=96	+ trans=5, amount=540	❌ 有交易	-

最终结果：

customer_id	count_no_trans
9	1
30	1
54	2

1280. 学生们参加各科测试的次数 `Easy`（CROSS JOIN + LEFT JOIN）

表结构：

Students(student_id, student_name)
Subjects(subject_name)
Examinations(student_id, subject_name)

1
SELECT s.student_id,
2
       s.student_name,
3
       su.subject_name,
4
       COUNT(e.subject_name) AS attended_exams
5
FROM Students s
6
         JOIN Subjects su -- 先做笛卡尔积
7
         LEFT JOIN Examinations e -- 再左连考试表
8
                   ON e.student_id = s.student_id AND e.subject_name = su.subject_name
9
GROUP BY s.student_id, su.subject_name
10
ORDER BY s.student_id, su.subject_name;

执行流程：

1
Students × Subjects（笛卡尔积）：
2
┌─────────────┬──────────┐
3
│ student_id  │ subject  │
4
├─────────────┼──────────┤
5
│ 1, Alice    │ Math     │  ← LEFT JOIN Exam: 找到1条 → count=1
6
│ 1, Alice    │ Physics  │  ← LEFT JOIN Exam: 找到0条 → count=0
7
│ 1, Alice    │ Math     │  ...
8
│ 2, Bob      │ Math     │
9
│ 2, Bob      │ Physics  │
10
└─────────────┴──────────┘
11

12
→ LEFT JOIN Examinations（保留所有学生×科目组合）
13
→ GROUP BY (student_id, subject_name)
14
→ COUNT(e.subject_name) 只计非 NULL

核心点：先 Students JOIN Subjects 生成「每个学生 × 每个科目」的全组合，再 LEFT JOIN 考试表计算参加次数

1731. 每位经理的下属员工数量 `Easy`（自连接）

1
SELECT e2.employee_id,
2
       e2.name,
3
       COUNT(e1.reports_to)  AS reports_count,
4
       ROUND(AVG(e1.age), 0) AS average_age
5
FROM Employees e1
6
         JOIN Employees e2 ON e1.reports_to = e2.employee_id
7
GROUP BY e1.reports_to
8
ORDER BY e2.employee_id;

执行流程：

Employees 表：

employee_id	name	reports_to	age
9	Hercy	NULL	43
6	Alice	9	31
4	Bob	9	36
2	Omer	6	24

自连接（e1=下属, e2=经理）：

e1.name(下属)	e1.age	e2.employee_id(经理)	e2.name(经理)
Alice	31	9	Hercy
Bob	36	9	Hercy
Omer	24	6	Alice

GROUP BY e1.reports_to 后：

employee_id	name	reports_count	average_age
9	Hercy	2	ROUND((31+36)/2) = 34
6	Alice	1	24

1978. 上级经理已离职的公司员工 `Easy`（LEFT JOIN + IS NULL）

1
SELECT e1.employee_id
2
FROM Employees e1
3
         LEFT JOIN Employees e2 ON e1.manager_id = e2.employee_id
4
WHERE e1.salary < 30000
5
  AND e2.employee_id IS NULL
6
  AND e1.manager_id IS NOT NULL
7
ORDER BY e1.employee_id;

执行流程：

e1(员工)	e1.manager_id	e1.salary	e2(经理)匹配	e2 IS NULL?	manager_id IS NOT NULL?	结果
3, Mary	1	25000	(id=1 存在)	❌	✅	❌ 经理未离职
7, Robert	99	20000	(id=99 不存在)	✅	✅	✅
11, Brad	5	28000	(id=5 不存在)	✅	✅	✅
13, Jason	NULL	15000	(无匹配)	✅	❌	❌ 无经理

三个条件缺一不可：salary < 30000 + 经理不存在(LEFT JOIN 后 IS NULL) + 有经理(IS NOT NULL)

三、GROUP BY + HAVING（分组与聚合）

WHERE vs HAVING 对比

1
WHERE：在分组前过滤行          HAVING：在分组后过滤组
2
┌─────────────┐              ┌─────────────┐
3
│  原始数据     │              │ 分组后的结果  │
4
│  WHERE 过滤  │ → GROUP BY → │ HAVING 过滤  │ → 最终结果
5
│  （行级）     │              │ （组级）      │
6
└─────────────┘              └─────────────┘
7
不能用聚合函数                  可以用聚合函数

0511. 游戏玩法分析 I `Easy`

表结构：Activity(player_id, device_id, event_date, games_played)

题目：查询每位玩家第一次登录的日期。

1
SELECT player_id, MIN(event_date) AS first_login
2
FROM Activity
3
GROUP BY player_id;

执行流程：

原始 Activity 表	→ GROUP BY player_id	→ MIN(event_date)
1, 2, 2016-03-01, 5	player_id=1: {2016-03-01, 2016-05-02}	2016-03-01
1, 2, 2016-05-02, 6	player_id=2: {2017-06-25}	2017-06-25
2, 3, 2017-06-25, 1	player_id=3: {2016-03-02, 2018-07-03}	2016-03-02
3, 1, 2016-03-02, 0
3, 4, 2018-07-03, 5

0182. 查找重复的电子邮箱 `Easy`

表结构：Person(id, email)

题目：找出重复的邮箱。

1
SELECT email AS Email
2
FROM Person
3
GROUP BY email
4
HAVING COUNT(email) > 1;

执行流程：

Person 表：

id	email
1	a@b.com
2	c@d.com
3	a@b.com

GROUP BY email 后：

email	COUNT	HAVING COUNT > 1?
a@b.com	2	✅
c@d.com	1	❌

最终结果：a@b.com

核心点：GROUP BY 分组后，HAVING 过滤出 COUNT > 1 的组（即重复的邮箱）

0596. 超过 5 名学生的课 `Easy`

表结构：Courses(student, class)

1
SELECT class
2
FROM Courses
3
GROUP BY class
4
HAVING COUNT(DISTINCT student) >= 5;

执行流程：

Courses 表：

student	class
A	Math
B	English
C	Math
D	Biology
E	Math
F	Math
G	Math
H	Math

GROUP BY class 后：

class	COUNT(DISTINCT student)	>= 5?
Math	6	✅
English	1	❌
Biology	1	❌

最终结果：Math

0570. 至少有5名直接下属的经理 `Medium`（自连接 + GROUP BY + HAVING）

1
SELECT e1.name
2
FROM Employee e1
3
         JOIN Employee e2 ON e1.Id = e2.managerId
4
GROUP BY e1.Id
5
HAVING COUNT(e2.Id) >= 5;

执行流程：

1
Employee 表（自连接）
2
e1=经理, e2=下属
3
┌─────────────┬──────────────────┐
4
│ e1.name(经理) │ e2.Id(下属)       │
5
├─────────────┼──────────────────┤
6
│ Stephen     │ 1, 2, 3, 4, 5    │  → COUNT=5 ✅
7
│ Alice       │ 6, 7             │  → COUNT=2 ❌
8
└─────────────┴──────────────────┘
9
→ GROUP BY e1.Id → HAVING COUNT >= 5 → Stephen

1045. 买下所有产品的客户 `Medium`（HAVING COUNT = 子查询）

表结构：

Customer(customer_id, product_key)
Product(product_key)

1
SELECT customer_id
2
FROM Customer
3
GROUP BY customer_id
4
HAVING COUNT(DISTINCT product_key) = (SELECT COUNT(*) FROM Product);

执行流程：

1
Product 表共 3 个产品（product_key: 1, 2, 3）
2
→ 子查询: SELECT COUNT(*) FROM Product = 3
3

4
Customer 表:
5
┌─────────────┬────────────┐
6
│ customer_id │ product_key│
7
├─────────────┼────────────┤
8
│ 1           │ 1          │
9
│ 1           │ 2          │
10
│ 1           │ 3          │   → COUNT(DISTINCT)=3 = 3 ✅
11
│ 2           │ 1          │
12
│ 2           │ 2          │   → COUNT(DISTINCT)=2 ≠ 3 ❌
13
│ 3           │ 1          │
14
│ 3           │ 2          │
15
│ 3           │ 3          │
16
│ 3           │ 1(重复)    │   → COUNT(DISTINCT)=3 = 3 ✅
17
└─────────────┴────────────┘
18

19
最终结果: customer_id = 1, 3

核心点：COUNT(DISTINCT product_key) 去重后与 Product 总数比较

1084. 销售分析 III `Easy`（HAVING + MIN/MAX）

表结构：

Product(product_id, product_name, unit_price)
Sales(seller_id, product_id, buyer_id, sale_date, quantity, price)

题目：找仅在 2019 春季售出的产品。

1
SELECT p.product_id, p.product_name
2
FROM Product p
3
         JOIN Sales s ON p.product_id = s.product_id
4
GROUP BY s.product_id
5
HAVING MIN(s.sale_date) >= '2019-01-01'
6
   AND MAX(s.sale_date) <= '2019-03-31';

执行流程：

product_id	所有 sale_date	MIN	MAX	都在春季?
1	2019-02-17, 2019-02-25	2019-02-17	2019-02-25	✅
2	2019-02-01, 2019-04-04	2019-02-01	2019-04-04	❌ (4月超出)
3	2019-03-10	2019-03-10	2019-03-10	✅

核心点：用 MIN/MAX 判断所有销售记录是否都在目标范围内

1587. 银行账户概要 II `Easy`（GROUP BY + HAVING SUM）

1
SELECT u.name, SUM(t.amount) AS balance
2
FROM Users u
3
         JOIN Transactions t ON u.account = t.account
4
GROUP BY t.account
5
HAVING SUM(t.amount) > 10000;

执行流程：

Users	Transactions	JOIN + GROUP BY	HAVING > 10000
account=1, Alice	account=1, +7000	Alice: 7000+7000=14000	✅
account=2, Bob	account=1, +7000	Bob: 3000-5000=-2000	❌
	account=2, +3000
	account=2, -5000

最终结果：

name	balance
Alice	14000

1193. 每月交易 I `Medium`（条件聚合 SUM + IF）

表结构：Transactions(id, country, state, amount, trans_date)

题目：按月和国家统计交易数、已批准交易数及金额。

1
SELECT DATE_FORMAT(trans_date, '%Y-%m') AS month, country,
2
       COUNT(state) AS trans_count,
3
       SUM(IF(state = 'approved', 1, 0)) AS approved_count,
4
       SUM(amount) AS trans_total_amount,
5
       SUM(IF(state = 'approved', amount, 0)) AS approved_total_amount
6
FROM Transactions
7
GROUP BY month, country;

执行流程：

原始 Transactions 表：

id	country	state	amount	trans_date
121	US	approved	1000	2019-01-18
122	US	declined	2000	2019-01-19
123	US	approved	3000	2019-01-27
124	DE	approved	2000	2019-01-14

GROUP BY (month, country) 后：

month	country	trans_count	approved_count	trans_total	approved_total
2019-01	US	3	SUM(1,0,1)=2	6000	1000+3000=4000
2019-01	DE	1	SUM(1)=1	2000	2000

核心点：SUM(IF(state='approved', 1, 0)) 实现条件计数——approved 记 1，否则记 0

1393. 股票的资本损益 `Medium`（CASE WHEN + SUM）

表结构：Stocks(stock_name, operation, operation_day, price)

1
SELECT stock_name,
2
       SUM(CASE
3
               WHEN operation = 'Buy' THEN -price
4
               WHEN operation = 'Sell' THEN price END) AS capital_gain_loss
5
FROM Stocks
6
GROUP BY stock_name;

执行流程：

stock_name	operation	price	CASE 结果
Leetcode	Buy	1000	-1000
Leetcode	Sell	9000	+9000
Corona	Buy	3000	-3000
Corona	Sell	1580	+1580

GROUP BY stock_name 后：

stock_name	capital_gain_loss
Leetcode	-1000 + 9000 = 8000
Corona	-3000 + 1580 = -1420

Buy 取负（支出），Sell 取正（收入），SUM 求和得到净损益

1484. 按日期分组销售产品 `Easy`（GROUP_CONCAT）

表结构：Activities(sell_date, product)

1
SELECT sell_date,
2
       COUNT(DISTINCT product)                         AS num_sold,
3
       GROUP_CONCAT(DISTINCT product ORDER BY product) AS products
4
FROM Activities
5
GROUP BY sell_date;

执行流程：

原始 Activities	→ GROUP BY sell_date	→ GROUP_CONCAT
2020-05-30, Headphone	2020-05-30: {Headphone, Basketball, PC}	2020-05-30: “Basketball,Headphone,PC”
2020-06-01, Pencil	2020-06-01: {Pencil, Bathing}	2020-06-01: “Bathing,Pencil”
2020-06-02, Mask	2020-06-02: {Mask, Bathing}	2020-06-02: “Bathing,Mask”
2020-05-30, Basketball		COUNT(DISTINCT)=3
2020-06-01, Bathing		COUNT(DISTINCT)=2
2020-05-30, PC
2020-06-02, Bathing

核心点：GROUP_CONCAT(DISTINCT product ORDER BY product) 去重 + 排序 + 逗号拼接

1693. 每天的领导和合伙人 `Easy`

1
SELECT date_id,
2
       make_name,
3
       COUNT(DISTINCT lead_id)    AS unique_leads,
4
       COUNT(DISTINCT partner_id) AS unique_partners
5
FROM DailySales
6
GROUP BY date_id, make_name;

执行流程：

原始 DailySales	→ GROUP BY (date_id, make_name)	→ COUNT(DISTINCT)
2020-12-8, Toyota, lead=0, partner=1	(2020-12-8, Toyota):	unique_leads=2 (0,1)
2020-12-8, Toyota, lead=1, partner=0	leads={0,1,1} → DISTINCT={0,1}	unique_partners=2 (0,1)
2020-12-8, Toyota, lead=1, partner=2	partners={1,0,2} → DISTINCT={0,1,2}
2020-12-7, Toyota, lead=0, partner=1	(2020-12-7, Toyota):	unique_leads=1 (0)
2020-12-7, Toyota, lead=0, partner=0	leads={0,0} → DISTINCT={0}	unique_partners=2 (0,1)

四、子查询（IN / EXISTS / 相关子查询）

0619. 只出现一次的最大数字 `Easy`

表结构：MyNumbers(num)（无主键，可能有重复）

1
SELECT MAX(num) AS num
2
FROM (SELECT num
3
      FROM MyNumbers
4
      GROUP BY num
5
      HAVING COUNT(num) = 1) AS numbers;

执行流程：

1
原始 MyNumbers:          → GROUP BY num + HAVING COUNT=1:    → MAX():
2
┌──────┐                ┌──────┐                           ┌──────┐
3
│ num  │                │ num  │                           │ num  │
4
├──────┤                ├──────┤                           ├──────┤
5
│ 8    │                │ 8    │ ← 出现1次 ✅               │      │
6
│ 8    │                │ 6    │ ← 出现1次 ✅               │  6   │
7
│ 3    │                │      │  3 出现2次 ❌              │      │
8
│ 3    │                │      │  1 出现3次 ❌              │      │
9
│ 7    │                │ 7    │ ← 出现1次 ✅               │      │
10
│ 6    │                └──────┘                           └──────┘
11
│ 6    │
12
│ 1    │
13
│ 1    │
14
│ 1    │
15
└──────┘

0585. 2016年的投资 `Medium`（多重子查询）

表结构：Insurance(pid, tiv_2015, tiv_2016, lat, lon)

题目：2015 投保额与他人相同 + 城市坐标唯一 → 求 2016 投保额之和。

1
SELECT ROUND(SUM(tiv_2016), 2) AS tiv_2016
2
FROM Insurance
3
WHERE (lat, lon) IN
4
      (SELECT lat, lon FROM Insurance GROUP BY lat, lon HAVING COUNT(pid) = 1)
5
  AND tiv_2015 IN
6
      (SELECT tiv_2015 FROM Insurance GROUP BY tiv_2015 HAVING COUNT(pid) > 1);

执行流程：

1
原始 Insurance 表:
2
┌─────┬──────────┬──────────┬──────┬──────┐
3
│ pid │ tiv_2015 │ tiv_2016 │ lat  │ lon  │
4
├─────┼──────────┼──────────┼──────┼──────┤
5
│ 1   │ 10       │ 5        │ 10   │ 10   │
6
│ 2   │ 20       │ 20       │ 20   │ 20   │
7
│ 3   │ 10       │ 30       │ 20   │ 20   │  ← lat,lon 与 pid=2 相同！
8
│ 4   │ 10       │ 40       │ 40   │ 40   │
9
└─────┴──────────┴──────────┴──────┴──────┘
10

11
子查询1: 城市坐标唯一的 → (10,10) 和 (40,40) → pid=1, 4
12
子查询2: 2015投保额重复的 → tiv_2015=10 (出现3次) → pid=1,3,4
13

14
两个条件取交集: pid=1 和 pid=4
15
→ SUM(tiv_2016) = 5 + 40 = 45

核心点：两个子查询分别筛选，WHERE 中 AND 取交集

0185. 部门工资前三高的所有员工 `Hard`（相关子查询）

表结构：

Employee(id, name, salary, departmentId)
Department(id, name)

1
SELECT d.name AS Department, e.name AS Employee, e.salary AS Salary
2
FROM Employee e
3
         JOIN Department d ON e.departmentId = d.id
4
WHERE (SELECT COUNT(DISTINCT e2.salary)
5
       FROM Employee e2
6
       WHERE e.salary < e2.salary
7
         AND e.departmentId = e2.departmentId) < 3;

执行流程：

Employee 表：

id	name	salary	deptId
1	Joe	85000	1
2	Henry	80000	2
3	Sam	60000	2
4	Max	90000	1
5	Janet	69000	1
6	Randy	85000	1

对每个员工，相关子查询计算「同部门中工资比我高的不同工资金额数」：

员工	部门	子查询：同部门比我高的不同 salary	COUNT	< 3?
Joe(85000)	1	{90000}	1	✅
Henry(80000)	2	{}	0	✅
Sam(60000)	2	{80000}	1	✅
Max(90000)	1	{}	0	✅
Janet(69000)	1	{85000, 90000}	2	✅
Randy(85000)	1	{90000}	1	✅

核心点：相关子查询引用外层 e.salary 和 e.departmentId，COUNT(DISTINCT) 确保同薪金不重复计数

1789. 员工的直属部门 `Easy`

表结构：Employee(employee_id, department_id, primary_flag)

1
SELECT employee_id, department_id
2
FROM Employee
3
WHERE primary_flag = 'Y'
4
   OR employee_id IN (SELECT employee_id
5
                      FROM Employee
6
                      GROUP BY employee_id
7
                      HAVING COUNT(employee_id) = 1);

执行流程：

1
Employee 表:
2
┌─────────────┬──────────────┬──────────────┐
3
│ employee_id │ department_id│ primary_flag │
4
├─────────────┼──────────────┼──────────────┤
5
│ 1           │ 1            │ N            │  ← 只有1个部门 → 子查询命中 ✅
6
│ 2           │ 1            │ Y            │  ← primary_flag=Y ✅
7
│ 2           │ 2            │ N            │  ← 不满足任何条件 ❌
8
│ 3           │ 2            │ N            │  ← 只有1个部门 → 子查询命中 ✅
9
│ 4           │ 1            │ N            │  ← 有2个部门，primary都不是Y → 看：
10
│ 4           │ 2            │ N            │    子查询 COUNT=2≠1 ❌, primary≠Y ❌
11
└─────────────┴──────────────┴──────────────┘
12

13
最终结果: (1,1), (2,1), (3,2)

核心点：OR 连接两个条件——要么标记为主部门，要么只有一个部门

五、窗口函数（RANK / SUM OVER / ROWS BETWEEN）

窗口函数执行原理

1
普通 GROUP BY：每组只输出一行         窗口函数：每行都输出，但聚合范围是「窗口」
2
┌────────────┐                       ┌────────────────────────┐
3
│ dept │ AVG │                       │ emp │ dept │ salary │ AVG(dept) │
4
├──────┼─────┤                       ├─────┼──────┼────────┼──────────┤
5
│ A    │ 75  │                       │ 1   │ A    │ 80     │ 75       │ ← 同 dept 的平均
6
│ B    │ 60  │                       │ 2   │ A    │ 70     │ 75       │
7
└────────────┘                       │ 3   │ B    │ 60     │ 60       │
8
                                     └─────┴──────┴────────┴──────────┘

1204. 最后一个能进入巴士的人 `Medium`（累计求和窗口）

表结构：Queue(person_id, person_name, weight, turn)

题目：找最后一个上车且总重 ≤ 1000 的人。

1
SELECT person_name
2
FROM (SELECT person_name,
3
             turn,
4
             SUM(weight) OVER(ORDER BY turn) AS sum_weight
5
      FROM Queue) AS wei
6
WHERE sum_weight <= 1000
7
ORDER BY turn DESC LIMIT 1;

执行流程：

turn	person_name	weight	SUM() OVER(ORDER BY turn) 累计
1	Alice	250	250
2	Bob	350	250+350=600
3	Alex	400	600+400=1000
4	John	300	1000+300=1300
5	Winston	500	1300+500=1800

WHERE sum_weight <= 1000 后：Alice(250), Bob(600), Alex(1000)

ORDER BY turn DESC LIMIT 1：取 turn 最大的 → Alex

核心点：SUM() OVER(ORDER BY turn) 对每一行计算从第一行到当前行的累计和

1321. 餐馆营业额变化增长 `Medium`（7天滚动窗口）

表结构：Customer(customer_id, name, visited_on, amount)

题目：计算 7 天滚动窗口的消费总额和日均值。

1
SELECT visited_on, amount, average_amount
2
FROM (SELECT visited_on,
3
             SUM(amount)  OVER(ORDER BY visited_on
4
            ROWS BETWEEN 6 PRECEDING AND CURRENT ROW) AS amount, ROUND(AVG(amount) OVER(ORDER BY visited_on
5
            ROWS BETWEEN 6 PRECEDING AND CURRENT ROW), 2) AS average_amount,
6
             ROW_NUMBER() OVER(ORDER BY visited_on) AS rn
7
      FROM (SELECT visited_on, SUM(amount) AS amount
8
            FROM Customer
9
            GROUP BY visited_on) AS daily) AS ranked
10
WHERE rn > 6;

执行流程：

1
第1步：先按天聚合
2
  visited_on  | amount(当天总额)
3
  2019-01-01  | 130
4
  2019-01-02  | 110
5
  2019-01-03  | 140
6
  2019-01-04  | 100
7
  2019-01-05  | 110
8
  2019-01-06  | 130
9
  2019-01-07  | 150
10
  2019-01-08  | 120
11
  2019-01-09  | 200
12

13
第2步：7天滚动窗口（ROWS BETWEEN 6 PRECEDING AND CURRENT ROW）
14

15
  visited_on  | 窗口范围              | SUM   | AVG     | rn | >6?
16
  2019-01-01  | [01-01]               | 130   | 130.00  | 1  | ❌
17
  2019-01-02  | [01-01 ~ 01-02]       | 240   | 120.00  | 2  | ❌
18
  ...         | 窗口不足7天           | ...   | ...     | .. | ❌
19
  2019-01-07  | [01-01 ~ 01-07]       | 870   | 124.29  | 7  | ❌
20
  2019-01-08  | [01-02 ~ 01-08]       | 860   | 122.86  | 8  | ✅ → 输出
21
  2019-01-09  | [01-03 ~ 01-09]       | 950   | 135.71  | 9  | ✅ → 输出

核心点：ROWS BETWEEN 6 PRECEDING AND CURRENT ROW 定义了包含当前行和前 6 行的 7 天窗口。ROW_NUMBER() > 6 过滤掉窗口不足 7 天的前几行

1341. 电影评分 `Medium`（CTE + RANK + UNION ALL）

表结构：

Movies(movie_id, title)
Users(user_id, name)
MovieRating(movie_id, user_id, rating, created_at)

题目：① 评论最多的用户名 ② 2020年2月平均评分最高的电影名

1
WITH uion AS (SELECT u.user_id, u.name, m.title, mr.rating, mr.created_at
2
              FROM MovieRating mr
3
                       JOIN Users u ON mr.user_id = u.user_id
4
                       JOIN Movies m ON mr.movie_id = m.movie_id)
5
SELECT name AS results
6
FROM (SELECT name, RANK() OVER(ORDER BY COUNT(title) DESC, name) AS rk
7
      FROM uion
8
      GROUP BY user_id) AS max_user
9
WHERE rk = 1
10
UNION ALL
11
SELECT title AS results
12
FROM (SELECT title, RANK() OVER(ORDER BY AVG(rating) DESC, title) AS rk
13
      FROM uion
14
      WHERE created_at BETWEEN '2020-02-01' AND '2020-02-29'
15
      GROUP BY title) AS max_title
16
WHERE rk = 1;

执行流程：

1
第1步：CTE uion — 三表 JOIN
2
┌────────┬────────┬─────────────┬───────┬────────────┐
3
│ user_id│ name   │ title       │ rating│ created_at │
4
├────────┼────────┼─────────────┼───────┼────────────┤
5
│ 3      │ Daniel │ Ice         │ 5     │ 2020-02-14  │
6
│ 2      │ Daniel │ Detention   │ 3     │ 2020-02-12  │
7
│ ...    │ ...    │ ...         │ ...   │ ...         │
8
└────────┴────────┴─────────────┴───────┴────────────┘
9

10
第2步：子查询1 — 用户评论数排名
11
GROUP BY user_id → COUNT(title) → RANK() OVER(ORDER BY count DESC, name)
12
┌────────┬───────┬─────┐
13
│ name   │ count │ rk  │
14
├────────┼───────┼─────┤
15
│ Daniel │ 3     │ 1   │ ← WHERE rk=1 → 输出 "Daniel"
16
│ Gloria │ 1     │ 2   │
17
└────────┴───────┴─────┘
18

19
第3步：子查询2 — 2月电影平均评分排名
20
WHERE created_at BETWEEN '2020-02-01' AND '2020-02-29'
21
GROUP BY title → AVG(rating) → RANK() OVER(ORDER BY avg DESC, title)
22
┌─────────────┬───────┬─────┐
23
│ title       │ avg   │ rk  │
24
├─────────────┼───────┼─────┤
25
│ Ice         │ 4.5   │ 1   │ ← WHERE rk=1 → 输出 "Ice"
26
│ Detention   │ 3.0   │ 2   │
27
└─────────────┴───────┴─────┘
28

29
第4步：UNION ALL 合并
30
┌──────────┐
31
│ results  │
32
├──────────┤
33
│ Daniel   │
34
│ Ice      │
35
└──────────┘

核心点：RANK() 处理平局（ORDER BY count DESC, name 确保平局取字典序小的）

六、CASE WHEN（条件表达式）

0610. 判断三角形 `Easy`

表结构：Triangle(x, y, z)

1
SELECT x,
2
       y,
3
       z,
4
       CASE
5
           WHEN x + y > z AND x + z > y AND y + z > x THEN 'Yes'
6
           ELSE 'No' END AS triangle
7
FROM Triangle;

执行流程：

x	y	z	x+y>z?	x+z>y?	y+z>x?	全满足?	triangle
13	15	30	28>30 ❌	43>15 ✅	45>13 ✅	❌	No
10	20	15	30>15 ✅	25>20 ✅	35>10 ✅	✅	Yes

0626. 换座位 `Medium`

表结构：Seat(id, student) — id 从 1 连续

题目：交换相邻座位号，奇数个学生时最后一个不动。

1
SELECT CASE
2
           WHEN id % 2 = 0 THEN id - 1
3
           WHEN id % 2 = 1 AND id != (SELECT COUNT(*) FROM Seat) THEN id + 1
4
       ELSE id
5
END
6
AS id, student
7
FROM Seat ORDER BY id;

执行流程：

原始 id	student	id % 2	总行数	CASE 结果	新 id
1	Abbot	1	5	奇数且≠5 → id+1	2
2	Doris	0	5	偶数 → id-1	1
3	Emerson	1	5	奇数且≠5 → id+1	4
4	Green	0	5	偶数 → id-1	3
5	Jeames	1	5	奇数且=5(最后一行) → id	5

ORDER BY id 后：

id	student
1	Doris
2	Abbot
3	Green
4	Emerson
5	Jeames

核心点：子查询 COUNT(*) 判断总行数，最后一行如果是奇数 id 则保持不变

0627. 变更性别 `Easy`（UPDATE + CASE）

1
UPDATE Salary
2
SET sex = CASE WHEN sex = 'm' THEN 'f' WHEN sex = 'f' THEN 'm' END;

执行流程：

id	name	sex(前)	→ CASE →	sex(后)
1	A	m	→ f	f
2	B	f	→ m	m
3	C	f	→ m	m
4	D	m	→ f	f

1907. 按分类统计薪水 `Medium`（UNION + IF）

表结构：Accounts(account_id, income)

题目：按 Low(<20000) / Average(20000-50000) / High(>50000) 统计账户数。

1
SELECT 'Low Salary' AS category, SUM(IF(income < 20000, 1, 0)) AS accounts_count
2
FROM Accounts
3
UNION
4
SELECT 'Average Salary', SUM(IF(income >= 20000 AND income <= 50000, 1, 0))
5
FROM Accounts
6
UNION
7
SELECT 'High Salary', SUM(IF(income > 50000, 1, 0))
8
FROM Accounts;

执行流程：

1
Accounts 表: income = [8000, 25000, 30000, 60000, 15000]
2

3
第1个 SELECT: 'Low Salary', SUM(IF(income<20000,1,0))
4
  → 8000→1, 25000→0, 30000→0, 60000→0, 15000→1 → SUM=2
5

6
第2个 SELECT: 'Average Salary', SUM(IF(20000≤income≤50000,1,0))
7
  → 8000→0, 25000→1, 30000→1, 60000→0, 15000→0 → SUM=2
8

9
第3个 SELECT: 'High Salary', SUM(IF(income>50000,1,0))
10
  → 8000→0, 25000→0, 30000→0, 60000→1, 15000→0 → SUM=1
11

12
UNION 合并:
13
┌──────────────────┬───────────────┐
14
│ category         │ accounts_count│
15
├──────────────────┼───────────────┤
16
│ Low Salary       │ 2             │
17
│ Average Salary   │ 2             │
18
│ High Salary      │ 1             │
19
└──────────────────┴───────────────┘

核心点：UNION 确保三个类别都输出（即使某类别为 0），用字符串字面量作为分类名

七、UNION / UNION ALL（合并结果集）

UNION vs UNION ALL

1
UNION：去重合并            UNION ALL：不去重合并
2
┌──────┐  ┌──────┐       ┌──────┐  ┌──────┐
3
│ A    │  │ A    │       │ A    │  │ A    │
4
│ B    │  │ C    │       │ B    │  │ C    │
5
└──────┘  └──────┘       └──────┘  └──────┘
6
    ↓                         ↓
7
┌──────┐                  ┌──────┐
8
│ A    │ ← 去重           │ A    │
9
│ B    │                  │ A    │ ← 保留
10
│ C    │                  │ B    │
11
└──────┘                  │ C    │
12
                          └──────┘

1795. 每个产品在不同商店的价格 `Easy`（列转行）

表结构：Products(product_id, store1, store2, store3)

题目：将列转行，输出 (product_id, store, price)。

1
SELECT product_id, 'store1' AS store, store1 AS price
2
FROM Products
3
WHERE store1 IS NOT NULL
4
UNION ALL
5
SELECT product_id, 'store2' AS store, store2 AS price
6
FROM Products
7
WHERE store2 IS NOT NULL
8
UNION ALL
9
SELECT product_id, 'store3' AS store, store3 AS price
10
FROM Products
11
WHERE store3 IS NOT NULL;

执行流程：

1
原始 Products 表（宽表）:
2
┌────────────┬────────┬────────┬────────┐
3
│ product_id │ store1 │ store2 │ store3 │
4
├────────────┼────────┼────────┼────────┤
5
│ 0          │ 95     │ 100    │ 105    │
6
│ 1          │ 70     │ NULL   │ 80     │
7
└────────────┴────────┴────────┴────────┘
8

9
UNION ALL 后（长表）:
10
┌────────────┬────────┬───────┐
11
│ product_id │ store  │ price │
12
├────────────┼────────┼───────┤
13
│ 0          │ store1 │ 95    │
14
│ 0          │ store2 │ 100   │
15
│ 0          │ store3 │ 105   │
16
│ 1          │ store1 │ 70    │
17
│ 1          │ store3 │ 80    │  ← store2=NULL 被过滤
18
└────────────┴────────┴───────┘

核心点：UNION ALL 将宽表的多列转为长表的多行，WHERE IS NOT NULL 过滤无价格的商店

1164. 指定日期的产品价格 `Medium`（UNION + 子查询）

表结构：Products(product_id, new_price, change_date)

题目：找 2019-08-16 时所有产品的价格（初始价格=10）。

1
-- 有变更记录的产品：取 ≤ 2019-08-16 的最近一次价格
2
SELECT product_id, new_price AS price
3
FROM Products
4
WHERE (product_id, change_date) IN
5
      (SELECT product_id, MAX(change_date)
6
       FROM Products
7
       WHERE change_date <= '2019-08-16'
8
       GROUP BY product_id)
9
UNION
10
-- 无变更记录的产品：价格为默认 10
11
SELECT product_id, 10 AS price
12
FROM Products
13
WHERE (product_id, change_date) IN
14
      (SELECT product_id, MIN(change_date)
15
       FROM Products
16
       GROUP BY product_id
17
       HAVING MIN(change_date) > '2019-08-16')
18
ORDER BY product_id;

执行流程：

1
Products 表:
2
┌────────────┬───────────┬─────────────┐
3
│ product_id │ new_price │ change_date │
4
├────────────┼───────────┼─────────────┤
5
│ 1          │ 20        │ 2019-08-14  │  ← ≤ 08-16, 最近
6
│ 2          │ 50        │ 2019-08-01  │  ← ≤ 08-16, 最近
7
│ 1          │ 10        │ 2019-08-17  │  ← > 08-16
8
│ 3          │ 30        │ 2019-08-19  │  ← 首次变更 > 08-16 → 默认 10
9
└────────────┴───────────┴─────────────┘
10

11
子查询1: ≤ 08-16 的最近变更 → (1, 2019-08-14), (2, 2019-08-01)
12
  → product 1 → price=20, product 2 → price=50
13

14
子查询2: 首次变更 > 08-16 → (3, 2019-08-19)
15
  → product 3 → price=10 (默认)
16

17
UNION 合并:
18
┌────────────┬───────┐
19
│ product_id │ price │
20
├────────────┼───────┤
21
│ 1          │ 20    │
22
│ 2          │ 50    │
23
│ 3          │ 10    │
24
└────────────┴───────┘

八、字符串与日期函数

0550. 游戏玩法分析 IV `Medium`（DATEDIFF + 子查询）

表结构：Activity(player_id, device_id, event_date, games_played)

题目：首次登录第二天再次登录的玩家比率。

1
SELECT ROUND(COUNT(m.player_id) / COUNT(DISTINCT a.player_id), 2) AS fraction
2
FROM Activity a
3
         LEFT JOIN (SELECT player_id, MIN(event_date) AS event_date
4
                    FROM Activity
5
                    GROUP BY player_id) m
6
                   ON a.player_id = m.player_id AND DATEDIFF(a.event_date, m.event_date) = 1;

执行流程：

1
第1步：子查询找首次登录日期
2
  player_id=1 → 2016-03-01
3
  player_id=2 → 2017-06-25
4
  player_id=3 → 2016-03-02
5

6
第2步：LEFT JOIN 条件: 同玩家 + DATEDIFF=1（次日登录）
7
  Activity(1, 2016-03-02) JOIN m(1, 2016-03-01) → DATEDIFF=1 ✅ → m.player_id=1
8
  Activity(1, 2016-03-01) JOIN m(1, 2016-03-01) → DATEDIFF=0 ❌
9
  Activity(2, 2017-06-25) JOIN m(2, 2017-06-25) → DATEDIFF=0 ❌
10
  Activity(3, 2018-07-03) JOIN m(3, 2016-03-02) → DATEDIFF=488 ❌
11

12
第3步：计算比率
13
  COUNT(m.player_id) = 1（只有 player 1 次日登录）
14
  COUNT(DISTINCT a.player_id) = 3（总玩家数）
15
  fraction = 1/3 = 0.33

核心点：LEFT JOIN 确保所有玩家都被计入分母，DATEDIFF(a, b) = a - b 的天数差

0197. 上升的温度 `Easy`（DATEDIFF + 自连接）

表结构：Weather(id, recordDate, temperature)

1
SELECT w1.id
2
FROM Weather w1
3
         JOIN Weather w2 ON DATEDIFF(w1.recordDate, w2.recordDate) = 1
4
WHERE w1.temperature > w2.temperature;

执行流程：

w1 (今天)	w2 (昨天)	DATEDIFF	温度比较	结果
2015-01-02, 25°	2015-01-01, 10°	1 ✅	25 > 10 ✅	id=2
2015-01-03, 20°	2015-01-02, 25°	1 ✅	20 > 25 ❌	-
2015-01-04, 30°	2015-01-03, 20°	1 ✅	30 > 20 ✅	id=4

0180. 连续出现的数字 `Medium`（自连接 ×3）

表结构：Logs(id, num)

1
SELECT DISTINCT l1.Num AS ConsecutiveNums
2
FROM Logs l1,
3
     Logs l2,
4
     Logs l3
5
WHERE l1.Id = l2.Id - 1
6
  AND l2.Id = l3.Id - 1
7
  AND l1.Num = l2.Num
8
  AND l2.Num = l3.Num;

执行流程：

1
Logs 表:
2
┌────┬─────┐
3
│ id │ num │
4
├────┼─────┤
5
│ 1  │ 1   │
6
│ 2  │ 1   │
7
│ 3  │ 1   │  ← 1 连续3次 ✅
8
│ 4  │ 2   │
9
│ 5  │ 1   │
10
│ 6  │ 2   │
11
│ 7  │ 2   │  ← 2 只连续2次 ❌
12
└────┴─────┘
13

14
三表自连接条件: l1.id=l2.id-1 AND l2.id=l3.id-1
15
→ 匹配: (id=1,num=1), (id=2,num=1), (id=3,num=1)
16
→ l1.Num=l2.Num=l3.Num=1 ✅
17
→ DISTINCT 后结果: ConsecutiveNums = 1

1517. 查找拥有有效邮箱的用户 `Easy`（REGEXP）

1
SELECT *
2
FROM Users
3
WHERE mail REGEXP '^[a-zA-Z][a-zA-Z0-9_.-]*@leetcode\.com$' COLLATE utf8mb4_bin;

正则解析：

1
^[a-zA-Z]                    → 以字母开头
2
[a-zA-Z0-9_.-]*              → 后跟任意数量的字母/数字/下划线/点/破折号
3
@leetcode\.com$              → 以 @leetcode.com 结尾
4
COLLATE utf8mb4_bin          → 区分大小写（确保域名为小写）

执行流程：

user_id	name	mail	匹配?
1	Winston	winston@leetcode.com	✅
2	Jonathan	jonathanisgreat	❌ 无 @
3	Annabelle	bella-@leetcode.com	✅
4	Sally	sally.come@leetcode.com	✅
5	Marwan	quarz#2020@leetcode.com	❌ # 不允许
6	David	david1@gmail.com	❌ 域名不对
7	George	George@leetcode.com	❌ G 大写（utf8mb4_bin 区分大小写）

1527. 患某种疾病的患者 `Easy`（LIKE 模糊匹配）

表结构：Patients(patient_id, patient_name, conditions)

题目：找患 I 类糖尿病（DIAB1 开头）的患者。

1
SELECT *
2
FROM Patients
3
WHERE conditions LIKE '% DIAB1%'
4
   OR conditions LIKE 'DIAB1%';

执行流程：

patient_id	conditions	匹配方式	结果
1	DIAB100	LIKE ‘DIAB1%’ ✅（开头）	输出
2	SADIAB100	❌ 不匹配（SAD 不是空格分隔）	不输出
3	ASDIAB1	❌ 同上	不输出
4	FR DIAB100	LIKE ’% DIAB1%’ ✅（前面有空格）	输出
5	SAD DIAB100	LIKE ’% DIAB1%’ ✅	输出

⚠️ LIKE '%DIAB1%' 会误匹配 SADIAB100！必须用 '% DIAB1%'（前有空格）或 'DIAB1%'（在开头）

1667. 修复表中的名字 `Easy`（字符串函数）

1
SELECT user_id,
2
       CONCAT(UPPER(SUBSTRING(name, 1, 1)), LOWER(SUBSTRING(name, 2))) AS name
3
FROM Users
4
ORDER BY user_id;

执行流程：

user_id	name(原始)	SUBSTRING(name,1,1)	UPPER	SUBSTRING(name,2)	LOWER	CONCAT
1	aLICE	a	A	LICE	lice	Alice
2	bOB	b	B	OB	ob	Bob

九、CTE 与复杂查询

3554. 查找类别推荐对 `Hard`（CTE + 自连接）

表结构：

ProductPurchases(user_id, product_id, quantity)
ProductInfo(product_id, category, price)

题目：找同时购买两个类别的用户数 ≥ 3 的类别对。

1
WITH tab AS (SELECT pp.user_id, pi.category
2
             FROM ProductPurchases pp
3
                      JOIN ProductInfo pi ON pp.product_id = pi.product_id)
4
SELECT tab.category                AS category1,
5
       tab2.category               AS category2,
6
       COUNT(DISTINCT tab.user_id) AS customer_count
7
FROM tab
8
         JOIN tab AS tab2
9
              ON tab.user_id = tab2.user_id AND tab.category < tab2.category
10
GROUP BY tab.category, tab2.category
11
HAVING customer_count >= 3
12
ORDER BY customer_count DESC, category1, category2;

执行流程：

1
第1步：CTE tab — 关联购买记录和产品类别
2
┌─────────┬──────────┐
3
│ user_id │ category │
4
├─────────┼──────────┤
5
│ 1       │ A        │
6
│ 1       │ B        │
7
│ 2       │ A        │
8
│ 2       │ B        │
9
│ 3       │ A        │
10
│ 3       │ B        │
11
│ 4       │ A        │  ← 只买了 A，没有 B
12
└─────────┴──────────┘
13

14
第2步：自连接生成类别对（条件 category1 < category2 避免重复）
15
tab JOIN tab ON user_id 相同 AND tab.category < tab2.category
16
┌─────────┬───────────┬───────────┐
17
│ user_id │ category1 │ category2 │
18
├─────────┼───────────┼───────────┤
19
│ 1       │ A         │ B         │
20
│ 2       │ A         │ B         │
21
│ 3       │ A         │ B         │
22
│ 4       │ (无 B)    │           │ ← 不匹配
23
└─────────┴───────────┴───────────┘
24

25
第3步：GROUP BY (category1, category2) + HAVING ≥ 3
26
┌───────────┬───────────┬────────────────┬──────┐
27
│ category1 │ category2 │ COUNT(DISTINCT)│ ≥ 3? │
28
├───────────┼───────────┼────────────────┼──────┤
29
│ A         │ B         │ 3              │ ✅   │
30
└───────────┴───────────┴────────────────┴──────┘

核心点：tab.category < tab2.category 确保 (A,B) 和 (B,A) 只出现一次

1934. 确认率 `Medium`（LEFT JOIN + IF + IFNULL）

表结构：

Signups(user_id, time_stamp)
Confirmations(user_id, time_stamp, action)

题目：每个用户的确认率 = confirmed 数 / 总请求数，无请求为 0。

1
SELECT s.user_id,
2
       ROUND(IFNULL(SUM(IF(c.action = 'confirmed', 1, 0)) / COUNT(c.action), 0), 2)
3
           AS confirmation_rate
4
FROM Signups s
5
         LEFT JOIN Confirmations c ON s.user_id = c.user_id
6
GROUP BY s.user_id;

执行流程：

Signups	LEFT JOIN Confirmations	action	IF(confirmed)	COUNT(action)	比率
user=3	(3, confirmed)	confirmed → 1
user=3	(3, timeout)	timeout → 0	SUM=1	COUNT=2	1/2=0.5
user=7	(7, timeout)	timeout → 0
user=7	(7, timeout)	timeout → 0	SUM=0	COUNT=2	0/2=0
user=6	(无匹配)	NULL	SUM=NULL	COUNT=0	IFNULL(NULL,0)=0

最终结果：

user_id	confirmation_rate
3	0.50
7	0.00
6	0.00

十、正则表达式与模式匹配

3475. DNA 模式识别 `Medium`（CASE WHEN + LIKE + REGEXP）

表结构：Samples(sample_id, dna_sequence, species)

1
SELECT sample_id,
2
       dna_sequence,
3
       species,
4
       CASE WHEN dna_sequence LIKE 'ATG%' THEN 1 ELSE 0 END             AS has_start,
5
       CASE WHEN dna_sequence REGEXP 'TAA$|TAG$|TGA$' THEN 1 ELSE 0 END AS has_stop,
6
       CASE WHEN dna_sequence LIKE '%ATAT%' THEN 1 ELSE 0 END           AS has_atat,
7
       CASE WHEN dna_sequence LIKE '%GGG%' THEN 1 ELSE 0 END            AS has_ggg
8
FROM Samples;

模式解析：

模式	LIKE/REGEXP	含义
以 ATG 开头	`LIKE 'ATG%'`	% 匹配任意后续字符
以 TAA/TAG/TGA 结尾	`REGEXP 'TAA$\|TAG$\|TGA$'`	$ 锚定结尾，\| 是或
包含 ATAT	`LIKE '%ATAT%'`	% 在两端匹配任意前后缀
包含 GGG	`LIKE '%GGG%'`	同上

执行示例：

sample_id	dna_sequence	has_start	has_stop	has_atat	has_ggg
1	ATGCGATATGGGTAATAG	1 (ATG开头)	1 (TAG结尾)	1 (含ATAT)	1 (含GGG)
2	ATGCGGTAA	1	1 (TAA结尾)	0	0
3	CGCGCG	0	0	0	0

1683. 无效的推文 `Easy`

1
SELECT tweet_id
2
FROM Tweets
3
WHERE LENGTH(content) > 15;

0196. 删除重复的电子邮箱 `Easy`（DELETE + 自连接）

表结构：Person(id, email)

1
DELETE
2
p1 FROM Person p1
3
JOIN Person p2 ON p1.email = p2.email AND p1.id > p2.id;

执行流程：

1
删除前 Person 表:
2
┌────┬───────────┐
3
│ id │ email     │
4
├────┼───────────┤
5
│ 1  │ john@mail │  ← 保留（id 最小）
6
│ 2  │ bob@mail  │
7
│ 3  │ john@mail │  ← 删除（同 email，id 更大）
8
└────┴───────────┘
9

10
自连接条件: p1.email = p2.email AND p1.id > p2.id
11
→ p1(3, john@mail) JOIN p2(1, john@mail): email相同 AND 3>1 ✅ → DELETE p1
12
→ p1(1, john@mail) JOIN p2(3, john@mail): 1>3 ❌ → 不删
13
→ p1(2, bob@mail): 无同 email 的更小 id → 不删
14

15
删除后:
16
┌────┬───────────┐
17
│ id │ email     │
18
├────┼───────────┤
19
│ 1  │ john@mail │
20
│ 2  │ bob@mail  │
21
└────┴───────────┘

核心点：p1.id > p2.id 确保保留 id 最小的那条记录

附录：SQL 常用函数速查

聚合函数

函数	说明	示例
COUNT(*)	计行数（含 NULL）	`COUNT(*) FROM Users`
COUNT(col)	计非 NULL 行数	`COUNT(email)`
COUNT(DISTINCT col)	去重计数	`COUNT(DISTINCT user_id)`
SUM(col)	求和	`SUM(amount)`
AVG(col)	平均值	`AVG(rating)`
MIN/MAX(col)	最小/最大值	`MIN(event_date)`

条件表达式

写法	说明
`IF(cond, a, b)`	条件为真返回 a，否则 b
`CASE WHEN cond THEN a ELSE b END`	多条件分支
`IFNULL(a, b)`	a 为 NULL 返回 b

窗口函数

写法	说明
`RANK() OVER(ORDER BY col)`	排名（同值同名次，跳号）
`DENSE_RANK() OVER(ORDER BY col)`	排名（同值同名次，不跳号）
`ROW_NUMBER() OVER(ORDER BY col)`	行号（不重复）
`SUM(col) OVER(ORDER BY col)`	累计求和
`SUM(col) OVER(ORDER BY col ROWS BETWEEN N PRECEDING AND CURRENT ROW)`	N+1 行滑动窗口

日期函数

函数	说明	示例
DATEDIFF(a, b)	a-b 天数差	`DATEDIFF(d1, d2) = 1`
DATE_FORMAT(d, fmt)	格式化日期	`DATE_FORMAT(d, '%Y-%m')`
NOW() / CURDATE()	当前时间/日期

字符串函数

函数	说明
SUBSTRING(s, pos, len)	截取子串
UPPER(s) / LOWER(s)	大写/小写
CONCAT(s1, s2)	拼接
LENGTH(s)	长度
GROUP_CONCAT(col ORDER BY col)	分组拼接
REGEXP	正则匹配
LIKE	模式匹配（% 任意，_ 单字符）

💡 建议：SQL 考的不是复杂语法，而是把业务需求拆解成 SQL 执行步骤的能力。拿到题先想：① 需要哪些表？② 需要关联吗？③ 需要分组吗？④ 过滤条件在哪一步？⑤ 需要排序/截取吗？想清楚这五步，SQL 自然就写出来了。

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://muxiaowf.dpdns.org/blog/260809sql/

Blog底层更新记录

MuxiaoWF — Thu, 30 Jul 2026 00:00:00 GMT

前几天脑子发昏闲的无聊突然想把这个blog的底层库更新一下，再加上我这个人纯闲的和喜欢追求最新版，这里就纯当记录了。（写的页非常简单，仅供参考吧，慎重更新）

刚好过blog一周年了，权当“庆生😂”了

先说一下之前的情况，之前是Astro 5 + Tailwind 3 + DaisyUI 4的架构，升级后变为Astro 7 + Tailwind 4 + DaisyUI 5，Astro的配套组件全部最新，但是注意的是俺在写的时候TypeScript 7还没有支持Astro，因此只用了TypeScript 6最新版。

这里说一下更新会导致的浏览器适配问题，Tailwind v4要求Chrome ≥111、Edge ≥111、Firefox ≥128、Safari ≥16.4，更新会导致旧机型的不适配

更新开始

简单更新版本

package.json

1
// 新增依赖
2
 "@astrojs/markdown-remark": "^7.2.2"     // 独立 markdown 处理
3
 "@iconify/tailwind4": "^1.2.3"           // Tailwind 4 版 Iconify
4
 "@tailwindcss/vite": "^4.3.3"            // Tailwind Vite 插件（替代 @astrojs/tailwind）
5

6
// 移除依赖
7
 "@astrojs/tailwind": "^6.0.2"            // 不再需要
8
 "@iconify/tailwind": "^1.2.0"            // 替换为 tailwind4 版本
9
 "@typescript-eslint/parser": "^8.48.1"   // 不再需要
10
 "sass-embedded": "^1.93.3"               // SCSS → CSS 迁移
11
 "medium-zoom": "^1.1.0"                  // 移除
12
 "remark": "^15.0.1"                      // 由 @astrojs/markdown-remark 替代
13

14
 "typescript": "^5.9.3"
15
 "typescript": "^6.0.3"
16

17
// 其余均为直接版本升级

pnpm-workspace.yaml

1
allowBuilds:
2
  sharp: true
3
  swup: false
4
 unrs-resolver: true   // Astro 7 需要

astro.config.mjs Astro 配置迁移

1
 import tailwind from "@astrojs/tailwind";
2
 const playformCompress = (await import("@playform/compress")).default; // 同步 import
3
 import tailwindcss from "@tailwindcss/vite";   // Tailwind 4 使用 Vite 插件
4
 import { unified } from "@astrojs/markdown-remark";  // 独立 markdown processor
5

6
export default defineConfig({
7
  integrations: [
8
    // ... 其他 integrations
9
   tailwind({
10
     configFile: "./tailwind.config.mjs",
11
   }),
12
   // Tailwind 4 不再需要 integration
13
   playformCompress(),
14
   playformCompress({
15
     Image: false,        // 必须禁用，sharp 版本不兼容
16
     JavaScript: false,   // JS 由 terser 处理
17
   }),
18
  ],
19
  markdown: {
20
   remarkPlugins: [...],
21
   rehypePlugins: [...],
22
   processor: unified({    // 新的 markdown processor API
23
     remarkPlugins: [...],
24
     rehypePlugins: [...],
25
   }),
26
  },
27
  vite: {
28
   plugins: [tailwindcss()],  // Tailwind 4 Vite 插件
29
    build: {
30
     cssMinify: "esbuild",    // 必须！lightningcss 不支持 @apply
31
    },
32
   css: {
33
     preprocessorOptions: {
34
       scss: { api: "modern-compiler" },  // SCSS 配置移除
35
     },
36
   },
37
  },
38
 style: {
39
   scss: {
40
     includePaths: ["./src/styles"],  // 移除 SCSS 配置
41
   },
42
 },
43
});

cssMinify: "esbuild"：这是 Tailwind 4 迁移的必选项。Vite 默认使用 lightningcss 压缩 CSS，但不识别 Tailwind 的 @apply 指令，会输出约 120+ 条警告。esbuild 对于未知 at-rule 保持静默。
@playform/compress 禁用 Image: 该插件捆绑的 sharp 0.34.5 在处理不含 ICC 配置文件的 PNG 时抛出 colourspace: parameter space not set 错误。建议项目中图片预优化，无需二次压缩。
@playform/compress 禁用 JavaScript: JS 压缩已由 @rollup/plugin-terser 负责，避免重复处理。

Tailwind 4 改为 CSS-first 配置，不再需要 tailwind.config.mjs：建议参考Tailwind 4官方升级指南↗，里面有更新插件，理论上可以省去部分废弃/修改的css样式的适配（后面会提到）

1
// 删除 tailwind.config.mjs
2
 /** @type {import('tailwindcss').Config} */
3
 export default {
4
   content: ["./src/**/*.{astro,html,js,md,mdx,svelte,ts,tsx,vue}"],
5
   plugins: [daisyUI, typography, addDynamicIconSelectors()],
6
   daisyui: {
7
     themes: ["winter", "night"],
8
     darkTheme: "night",
9
     logs: false,
10
   },
11
 };

新建 src/styles/tailwind.css

1
@import "tailwindcss";
2
@import "./global.css";   /* 导入自定义全局样式 */
3

4
@theme {
5
  --font-sans: ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
6
}
7

8
@plugin "@tailwindcss/typography";
9
@plugin "@iconify/tailwind4";
10
@plugin "daisyui" {
11
  themes: winter --default, night --prefersdark;
12
  logs: false;
13
}

@theme 指令替代 theme.extend — 自定义主题值在 @theme 块中定义
@plugin 指令替代 plugins: [...] — Tailwind 插件使用 @plugin 导入
无需 content 配置 — Tailwind 4 自动检测模板文件
@import 替代 @tailwind base/components/utilities

DaisyUI 配置变化

1
// DaisyUI v4 (tailwind.config.mjs)
2
 daisyui: {
3
   themes: ["winter", "night"],
4
   darkTheme: "night",
5
   logs: false,
6
 }
7

8
// DaisyUI v5 (tailwind.css)
9
@plugin "daisyui" {
10
  themes: winter --default, night --prefersdark;
11
  logs: false;
12
}

部分破坏性变更，更多参见官方文档↗

特性	v4	v5
配置方式	JS 对象	CSS `@plugin` 指令
`input-bordered`	✅ 存在	❌ 移除，input 默认有边框
`btn-outline`	正常	行为略有不同
`shadow-sm`	✅	❌ 改为 `shadow-xs`
`collapse` 组件	HTML 结构	❌ 移除，需自行实现

DaisyUI 5 中很多组件样式行为有微妙变化，需要逐个组件检查

详细更新适配

Content Layer API 变更

Astro 7 的 Content Layer API 与 Astro 5 有显著不同。

新建 src/content.config.ts，将原来的src/content/config.ts可以直接重命名并易懂

1
import { defineCollection } from "astro:content";
2
import { z } from "astro/zod";
3
import { glob } from "astro/loaders";
4

5
const blog = defineCollection({
6
  loader: glob({
7
    pattern: ["**/*.{md,mdx}"],
8
    base: "./src/content/blog",
9
  }),
10
  schema: z.object({
11
    title: z.string(),
12
    description: z.string(),
13
    pubDate: z.coerce.date(),
14
    updated: z.coerce.date().optional(),
15
    // ... 其他字段
16
  }),
17
});
18

19
export const collections = { blog };

旧 API (Astro 5)	新 API (Astro 7)	说明
`blog.slug`	`blog.id`	slug 改名为 id
`blog.render()`	`render(blog)`	render 变为独立函数
`getCollection()` from `astro:content`	不变	但需单独导入 `render`

代码迁移示例

1
 import { getCollection } from "astro:content";
2
 import { getCollection, render } from "astro:content";
3

4
// slug → id
5
 <a href={`/blog/${post.slug}`}>
6
 <a href={`/blog/${post.id}`}>
7

8
// render() 调用
9
 const { Content } = await blog.render();
10
 const { Content } = await render(blog);
11

12
// getStaticPaths
13
 params: { slug: blog.slug },
14
 params: { slug: blog.id },

CSS 系统迁移：SCSS → Tailwind CSS

项目原先使用 SCSS（global.scss），现迁移为纯 CSS（global.css），利用 Tailwind 4 的 @apply + CSS nesting。

文件结构变化

1
src/styles/global.scss   (719 行, SCSS)
2
tailwind.config.mjs      (JS 配置)
3
src/styles/global.css    (1207 行, 纯 CSS)
4
src/styles/tailwind.css  (Tailwind 4 入口)

@tailwind 指令移除 — 全局样式中不再需要 @tailwind base/components/utilities
SCSS 特性替换：
- @mixin / @include → CSS @layer + 复用类
- $variable → CSS 自定义属性 --variable
- 嵌套选择器 → 原生 CSS Nesting（已广泛支持）
@apply 保持可用 — 在 global.css 中仍然可以使用 @apply

astro.config.mjs 中移除 SCSS 配置（部分上面已经修改过了）

1
style: {
2
  scss: {
3
    includePaths: ["./src/styles"],
4
  },
5
},
6
vite.css.preprocessorOptions.scss: {
7
  api: "modern-compiler",
8
},

Tailwind组件的切换在上面说过理论上可以使用官方提供的一个插件进行，但是这里需要注意的是插件似乎是简单的检索替换，如果在部分文件中使用了检索到的相同的变量名也会被错误替换，建议构建重试再提交。

其他

js-yaml ^4 → ^5

1
import yaml from "js-yaml";
2
import * as yaml from "js-yaml";

Waline 组件的 define:vars 写法变化（Astro 7 不支持在 define:vars 中内联引用 Astro.props.X）

1
serverURL: Astro.props.serverURL,
2
lang: Astro.props.lang ?? "zh",
3
// 改为先解构再传入变量名
4
const { serverURL, lang = "zh" } = Astro.props;
5
// define:vars 中直接引用变量
6
serverURL,
7
lang,

其他的就是 Astro 7 的空白符（whitespace）规则改动多行 inline 元素换行，旧版自动生成空格；新版 JSX 模式，不生成空格，行内文字直接贴在一起。最直接的可能就是license的作者和证书之间没有空格了，还有其他的地方可以自行调整一下。

另外，对于字体的，tailwind似乎在4的时候更新了字体（又或者是系统字体放在了前面），如果要维持3的字体可以在tailwind.css中添加

1
@theme {
2
  --font-sans: ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
3
}

还有一件事，在之前似乎会出现md:xx lg:xx，会使部分组件之前的lg屏幕也是以md屏幕的样式进行展示，更新后会进行修正，使lg屏幕版本正确显示组件样式，这样会导致看起来大小似乎不一样。如果要维持可对部分组件进行调整（我直接将lg改为2xl才修改就可以了（）

再再再的事，对于global.css中还可以添加：

1
@layer base {
2
    *,
3
    ::after,
4
    ::before,
5
    ::backdrop,
6
    ::file-selector-button {
7
        border-color: var(--color-gray-200, currentColor);
8
    }
9

10
    input::placeholder,
11
    textarea::placeholder {
12
        color: var(--color-gray-400);
13
    }
14
    /*（可选）可点击元素鼠标指针样式*/
15
    button:not(:disabled),
16
    [role="button"]:not(:disabled) {
17
        cursor: pointer;
18
    }
19
    /*（建议）分割线 hr 上下外边距强制统一，主要是license的区域*/
20
    hr {
21
        margin-block: 1rem !important;
22
    }
23
}

如果你更新了pagefind从1.4.0到1.5.x，可能还需要更新search页面，可能会报错Pagefind: WASM Error (No pointer)

bundlePath 路径解析失败：@pagefind/default-ui 包通过检查 document.currentScript 来判断 pagefind.js 的位置。但当通过动态 import() 加载时（而且 Astro 通过 Vite 打包时），document.currentScript 永远为 null。所以 bundlePath 变成了 undefined。
构建产物中使用了错误的 baseUrl：当前的 dist/ 构建产物传入的是 baseUrl: “/pagefind/“，这会构造出类似 /pagefind/blog/文章路径这样的错误链接（应该用 / 作为 baseUrl），但这并非问题的根源——根源在于缺少 bundlePath。

即需要

1
const search = new PagefindUI({
2
 element: "#pagefind-search",
3
 bundlePath: "/pagefind/",
4
 showImages: false,
5
 ...
6
});

如果想的话还可以将pagefind default-ui 迁移为 component-ui，闲的话可以折腾一下

后记

见鬼了部署更新后无论怎么刷新都会报错，在本地还正常，我还以为是我组件的问题，结果发现是浏览器缓存的问题。删缓存又删了半天，一开始以为是vercel/cloudflare端的，结果发现就edge不能正常看，后面在Service Worker里搞了半天也不行，最后可以直接开发工具-应用-储存里直接全部清理掉就正常了，整了一天…

总结

更新 package.json 中的所有依赖版本
更新 pnpm-workspace.yaml 添加 unrs-resolver: true
执行 pnpm install
创建 src/styles/tailwind.css 作为 Tailwind 4 入口
删除 tailwind.config.mjs
迁移 global.scss → global.css（移除 @tailwind 指令）
更新 astro.config.mjs（Tailwind Vite 插件、Markdown processor、cssMinify 等）
创建 src/content.config.ts
批量替换所有 .svelte 和 .astro 文件中的 Tailwind 工具类
替换 blog.slug → blog.id，blog.render() → render(blog)
运行 pnpm build 验证构建成功

写在最后：累死我了，纯属吃力不讨好，纯属闲的。个人感觉就是构建的时候提速了一下，在vercel上原本需要两分半构建时间现在只要两分钟不到吧。但是这个和我有什么关系…适配的机型还变少了

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://muxiaowf.dpdns.org/blog/260730update/

Eino学习笔记 —— Agentic 进阶

MuxiaoWF — Mon, 20 Jul 2026 00:00:00 GMT

本笔记通过ai辅助生成，但对于代码阅读顺序应当没有问题（均使用eino官方的例子进行，个人认为官方的教程感觉有点太难懂了）

Eino Agentic 高级功能指南

📂 源码仓库：github.com/cloudwego/eino-examples↗

📖 系列文档：入门笔记 | Agentic 进阶 | 附录一 Flow | 附录二组件 | 附录三工具

📁 代码来源：

adk/agentic/research_assistant/ — AgenticModel + AgenticMessage 全功能研究助手

adk/agentic/retry_max_output_tokens/ — 输出截断自动重试

📖 前置知识：本指南假设你已经掌握入门笔记中一到五节的内容。

速览：ChatModel → AgenticModel 类型映射表（先看这里！）

在深入细节之前，先把核心映射记住——Agentic 就是所有类型名字加 Typed、所有 Message 换成 AgenticMessage：

普通版（Chat Completions）	Agentic 版（Responses API）
`openai.NewChatModel()`	`agenticopenai.New()` / `agenticark.New()`
`schema.UserMessage("...")`	`schema.UserAgenticMessage("...")`
`adk.NewChatModelAgent(...)`	`adk.NewTypedChatModelAgent[*schema.AgenticMessage](...)`
`adk.NewRunner(...)`	`adk.NewTypedRunner[*schema.AgenticMessage](...)`
`event.Output.MessageOutput.GetMessage()`	`adk.TypedGetMessage(event)`
`adk.ChatModelAgentMiddleware`	`adk.TypedChatModelAgentMiddleware[*schema.AgenticMessage]`
`adk.ModelRetryConfig`	`adk.TypedModelRetryConfig[*schema.AgenticMessage]`
`filesystem.New(...)`	`filesystem.NewTyped[*schema.AgenticMessage](...)`

🧠 一句话总结：Agentic 系列是 Eino 为 Responses API 设计的完整封装——用 AgenticModel 替代 ChatModel，用 AgenticMessage 替代 Message，其余概念（Agent / Runner / Middleware / Tool）的用法保持一致，但全部使用 Typed 泛型变体。

背景：Chat Completions API → Responses API

在入门笔记中，所有代码都基于 Chat Completions API（ChatModel + *schema.Message）。这是 OpenAI 2022 年推出的 API 形态。

但从 2025 年起，主流模型厂商开始推 Responses API，这是新一代 API 形态。两者的核心区别：

维度	Chat Completions API	Responses API
消息类型	`*schema.Message`（单一角色+内容）	`*schema.AgenticMessage`（含 ContentBlocks）
模型接口	`einoModel.ChatModel`	`einoModel.AgenticModel`
Agent 类型	`adk.NewChatModelAgent`	`adk.NewTypedChatModelAgent[*schema.AgenticMessage]`
Runner 类型	`adk.NewRunner`	`adk.NewTypedRunner[*schema.AgenticMessage]`
一次调用返回	一条文本回复	多个有序结构化事件（推理→工具调用→再推理→文本）
服务端工具	❌ 全在客户端执行	✅ 模型厂商侧直接执行（如 web_search）
输出截断检测	无标准信号	`status=incomplete` + `reason=max_output_tokens`

一、核心概念：AgenticMessage 与 ContentBlock

1.1 为什么需要 AgenticMessage？

在 Chat Completions API 中，一次模型调用只返回一条消息。Responses API 在一次调用中返回所有结构化的中间步骤。要承载这种”多事件”的返回，原来的 *schema.Message（只有一个 Role + Content 字符串）不够用了：

1
ChatModel 返回:  ┌──────────────────────────┐
2
                 │  Role: Assistant         │
3
                 │  Content: "答案是42"      │
4
                 └──────────────────────────┘
5
                 只有一条扁平消息
6

7
AgenticModel     ┌──────────────────────────────────────────────┐
8
返回:             │ Role: Assistant                             │
9
                  │ ContentBlocks: [                            │
10
                  │   [0] type: reasoning                       │
11
                  │       text: "我需要先搜索..."               │
12
                  │   [1] type: server_tool_call                │
13
                  │       name: web_search                      │
14
                  │   [2] type: reasoning                       │
15
                  │       text: "搜索结果显示..."               │
16
                  │   [3] type: text                            │
17
                  │       text: "根据分析，答案是42"             │
18
                  │ ]                                           │
19
                  └──────────────────────────────────────────────┘
20
                 一条消息里装了多个有序的结构化 Block

1.2 ContentBlock 类型速查

每个 Block 有一个 Type 字段表示类别：

Block 类型	含义	谁产生	出现在哪条消息里
`reasoning`	模型的推理/思考过程	模型	Assistant 消息
`text`	普通文本输出	模型	Assistant 消息
`server_tool_call`	调用服务端工具（如 web_search）	模型	Assistant 消息
`function_tool_call`	调用客户端本地工具	模型	Assistant 消息
`function_tool_result`	本地工具执行结果	框架	User 消息（反馈给模型）
`thinking`	深度思考内容	模型	Assistant 消息

🧠 关键理解：server_tool_call 在模型厂商的服务器上执行（你的代码看不到执行过程），function_tool_call 返回给你的 Agent 本地执行。

二、AgenticModel：连接 Responses API

2.1 两种厂商接入

1
import (
2
    einoModel "github.com/cloudwego/eino/components/model"
3
    "github.com/cloudwego/eino-ext/components/model/agenticark"     // 火山方舟 ARK
4
    "github.com/cloudwego/eino-ext/components/model/agenticopenai"  // OpenAI
5
)
6

7
// ARK
8
model, err := agenticark.New(ctx, &agenticark.Config{
9
    APIKey:  os.Getenv("ARK_API_KEY"),
10
    Model:   os.Getenv("ARK_MODEL_ID"),
11
    BaseURL: os.Getenv("ARK_BASE_URL"),
12
})
13

14
// OpenAI
15
model, err := agenticopenai.New(ctx, &agenticopenai.Config{
16
    APIKey:  os.Getenv("OPENAI_API_KEY"),
17
    Model:   os.Getenv("OPENAI_MODEL_ID"),
18
    BaseURL: os.Getenv("OPENAI_BASE_URL"),
19
})

2.2 服务端工具：Web Search

不需要自己写搜索 Tool——直接声明即可，搜索在模型厂商侧完成：

1
// ARK 服务端 web_search
2
agenticark.WithServerTools([]*agenticark.ServerToolConfig{
3
    {WebSearch: &arkResponses.ToolWebSearch{
4
        Type:  arkResponses.ToolType_web_search,
5
        Limit: ptrOf[int64](6),
6
    }},
7
})
8

9
// OpenAI 服务端 web_search
10
agenticopenai.WithServerTools([]*agenticopenai.ServerToolConfig{
11
    {WebSearch: &openaiResponses.WebSearchToolParam{
12
        Type: openaiResponses.WebSearchToolTypeWebSearch,
13
    }},
14
})

💡 服务端 vs 本地工具：服务端工具的调用和执行都在模型厂商侧，你的代码只会在 content_blocks 中看到一个 server_tool_call block，不会有对应的 function_tool_result——结果被模型直接在内部消费了。

三、Typed 泛型体系

3.1 完整组装示例（与入门笔记 §3 对照）

和入门笔记第三节的 Agent 组装步骤一模一样，只是类型都换成了 Typed + AgenticMessage：

1
func newResearchAssistant(ctx context.Context) (adk.TypedAgent[*schema.AgenticMessage], error) {
2
    // ─── 第1步：创建 AgenticModel ───
3
    agenticModel, _ := newAgenticModel(ctx)
4

5
    // ─── 第2步：创建本地工具（和之前一模一样，InferTool）───
6
    tools, _ := buildTools()
7

8
    // ─── 第3步：创建 TypedChatModelAgent ───
9
    agent, err := adk.NewTypedChatModelAgent[*schema.AgenticMessage](ctx,
10
        &adk.TypedChatModelAgentConfig[*schema.AgenticMessage]{
11
            Name:        "AgenticResearchAssistant",
12
            Instruction: "...",
13
            Model:       agenticModel,          // ← AgenticModel
14
            ToolsConfig: adk.ToolsConfig{       // ← 和 ChatModel 版本一样！
15
                ToolsNodeConfig: compose.ToolsNodeConfig{
16
                    Tools: tools,
17
                },
18
            },
19
            MaxIterations: 8,
20
        })
21
    return agent, err
22
}

其余逻辑（Middleware 等）和 ChatModel 版本完全一样，只需加 Typed 前缀

3.2 TypedRunner 的使用方式

1
// 创建（和之前一样的模式）
2
runner := adk.NewTypedRunner[*schema.AgenticMessage](adk.TypedRunnerConfig[*schema.AgenticMessage]{
3
    Agent:           agent,
4
    EnableStreaming: true,
5
})
6

7
// 构造输入（用 UserAgenticMessage 替代 UserMessage）
8
input := schema.UserAgenticMessage("请写一份研究报告...")
9

10
// 运行
11
iter := runner.Run(ctx, []*schema.AgenticMessage{input})
12

13
// 消费事件 —— ⚠️ 关键变化：用 TypedGetMessage
14
for {
15
    event, ok := iter.Next()
16
    if !ok { break }
17
    msg, _, err := adk.TypedGetMessage(event)  // ← 不是 GetMessage()
18
    if msg != nil {
19
        fmt.Print(msg.String())
20
    }
21
}

🧠 与入门笔记的对比：

1
// 旧：ChatModel 路径
2
msg, err := event.Output.MessageOutput.GetMessage()
3
// 新：AgenticModel 路径
4
msg, typedagentevent, err := adk.TypedGetMessage(event)

四、ModelRetryConfig：输出截断自动重试

4.1 问题场景

Responses API 中对每次调用有 max_output_tokens 限制。设置太小时输出被截断：

1
status=incomplete
2
incomplete_details.reason=max_output_tokens

4.2 解决方案

Eino ADK 提供 TypedModelRetryConfig，自动丢弃不完整输出、调大 budget、重新调用：

1
var retryMaxTokens = []int{4096, 8192, 16384}
2

3
ModelRetryConfig: &adk.TypedModelRetryConfig[*schema.AgenticMessage]{
4
    MaxRetries: len(retryMaxTokens),
5
    ShouldRetry: func(ctx context.Context, retryCtx *adk.TypedRetryContext[*schema.AgenticMessage]) *adk.TypedRetryDecision[*schema.AgenticMessage] {
6
        if !isMaxOutputTokensIncomplete(retryCtx.OutputMessage) {
7
            return nil  // 不需要重试
8
        }
9
        nextMaxTokens := retryMaxTokens[retryCtx.RetryAttempt-1]
10
        return &adk.TypedRetryDecision[*schema.AgenticMessage]{
11
            Retry:             true,
12
            AdditionalOptions: []einoModel.Option{einoModel.WithMaxTokens(nextMaxTokens)},
13
            Backoff:           100 * time.Millisecond,
14
        }
15
    },
16
},

4.3 与入门笔记 §4.4 节 ModelRetryConfig 的对比

维度	ChatModel 版	Agentic 版
类型	`adk.ModelRetryConfig`	`adk.TypedModelRetryConfig[*schema.AgenticMessage]`
检测依据	`err`（HTTP 错误）	`OutputMessage.ResponseMeta`（响应状态）
重试方式	原样重试	调大 `max_output_tokens` 后重试
适用场景	限流、网络错误	输出截断

五、Agentic 全景速查

5.1 新增能力

能力	ChatModel 有吗	AgenticModel 如何实现
推理过程可见	❌	`reasoning` ContentBlock
服务端工具	❌	`server_tool_call` + `WithServerTools`
输出截断检测	间接（finish_reason）	直接：`status=incomplete`
一次调用多事件	❌ 需多次往返	✅ 单次调用返回多个 ContentBlock
深度思考	❌	`thinking` ContentBlock + `WithReasoning`

5.2 常用 import 路径

1
// AgenticModel 实现
2
"github.com/cloudwego/eino-ext/components/model/agenticopenai"  // OpenAI Responses API
3
"github.com/cloudwego/eino-ext/components/model/agenticark"     // 火山方舟 ARK
4

5
// 核心接口
6
"github.com/cloudwego/eino/components/model"   // AgenticModel 接口
7
"github.com/cloudwego/eino/schema"             // AgenticMessage, ContentBlock
8
"github.com/cloudwego/eino/adk"                // TypedChatModelAgent, TypedRunner, TypedModelRetryConfig
9

10
// 中间件（Typed 版）
11
"github.com/cloudwego/eino/adk/middlewares/filesystem"  // filesystem.NewTyped
12

13
// 后端
14
"github.com/cloudwego/eino-ext/adk/backend/local"       // localbackend.NewBackend

5.3 总结：什么时候该用 Agentic？

1
你的场景                                      → 用什么
2
─────────────────────────────────────────────────────────
3
简单问答、一次性调用                           → ChatModel（[入门笔记](./note) §2）
4
多轮对话 + 本地工具 + 中断恢复                 → ChatModelAgent（[入门笔记](./note) §3）
5
需要服务端搜索（web_search）                   → AgenticModel ✅
6
需要看到模型的推理过程                         → AgenticModel ✅
7
需要处理输出截断自动重试                       → AgenticModel ✅
8
需要一次调用中混合推理+工具+文本               → AgenticModel ✅
9
现有 ChatModelAgent 代码跑得好好的              → 不用迁移，除非需要上述特性

🧠 渐进式采用：Agentic 并不是要替代 ChatModel——它们是两套并行的体系。当需要高级特性时，迁移路径也很清晰：把类型从 ChatModel/Message 换成 AgenticModel/AgenticMessage，其余逻辑基本不变。

📇 本篇速记卡片

1
见到 Typed 就用 AgenticMessage：
2
  NewChatModelAgent → NewTypedChatModelAgent[*AgenticMessage]
3
  NewRunner          → NewTypedRunner[*AgenticMessage]
4
  GetMessage()       → TypedGetMessage()
5
  ModelRetryConfig   → TypedModelRetryConfig
6
  filesystem.New → filesystem.NewTyped[*AgenticMessage]
7

8
ContentBlock 六种类型：reasoning / text / server_tool_call
9
                       function_tool_call / function_tool_result / thinking
10

11
新增能力：
12
  reasoning Block（推理可见）、server_tool_call（服务端工具）
13
  web_search（不用自己写搜索Tool）、输出截断检测+重试

📂 源码仓库：github.com/cloudwego/eino-examples↗

📖 继续阅读：

入门笔记 — Eino ADK 从 Hello World 到 Compose 编排

Agentic 进阶 — Responses API / AgenticMessage / Typed 泛型 ← 你在这里

附录一：Flow 流程模块 — ReAct Agent / Multi-Agent / 状态图

附录二：Components 组件模块 — A/B 路由 / HTTP 日志 / 检索增强 / 文档解析

附录三：Lambda 与调试工具 — Lambda 写法 / Devops / Mermaid 可视化

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://muxiaowf.dpdns.org/blog/260720eino-agentic/

Eino学习笔记 —— 附录1

MuxiaoWF — Mon, 20 Jul 2026 00:00:00 GMT

本笔记通过ai辅助生成，但对于代码阅读顺序应当没有问题（均使用eino官方的例子进行，个人认为官方的教程感觉有点太难懂了）

理论上个人感觉附录只做了解即可，需要时可进行查询

附录一：Flow 流程模块 — ReAct Agent 与 MultiAgent

📂 源码仓库：github.com/cloudwego/eino-examples↗

📖 系列文档：入门笔记 | Agentic 进阶 | 附录一 Flow | 附录二组件 | 附录三工具

📁 代码根目录：flow/agent/

📖 前置知识：本附录假设你已掌握入门笔记（一～七节）和 Agentic 进阶的内容。

速览：Flow vs ADK — 两套体系

Eino 提供了两套并行的 Agent 构建方式：

维度	ADK（入门笔记 / Agentic 进阶）	Flow（本附录）
入口	`adk.NewChatModelAgent` / `adk.NewTypedChatModelAgent`	`react.NewAgent` / `host.NewMultiAgent` / Compose Graph
抽象层级	高层封装，开箱即用	中低层，精细控制每个节点
编排方式	Agent + Runner + Middleware（声明式）	Graph + Node + Branch + State（命令式）
适用场景	快速构建标准 Agent 应用	自定义控制流、多 Agent 协作、精细状态管理

🧠 怎么选：ADK 能覆盖的场景优先用 ADK。需要自定义 ReAct 循环行为、运行时动态修改模型参数、多 Agent 状态图流转时用 Flow。

技术选型决策树

graph TD
    Q["你要做什么？"] --> Q1{"标准单 Agent
问答+工具+记忆？"}
    Q1 -->|是| ADK["用 ADK
入门笔记 §3 / Agentic 进阶 §3"]
    Q1 -->|否| Q2{"需要自定义
ReAct 循环行为？"}
    Q2 -->|是| REACT["用 react.NewAgent
本附录 §1/§2/§4"]
    Q2 -->|否| Q3{"需要多 Agent 协作？"}
    Q3 -->|调度模式| SUP["快速: ADK Supervisor
精细: Host MultiAgent
本附录 §6"]
    Q3 -->|流水线| PE["Plan-Execute
本附录 §7"]
    Q3 -->|复杂状态图| CUSTOM["自定义 Graph+State
本附录 §9"]
    Q3 -->|否| Q4{"需要浏览器/沙箱工具？"}
    Q4 -->|是| MANUS["参考 Manus Agent
本附录 §8"]

📇 本附录速记卡片

1
react.NewAgent({ToolCallingModel, ToolsConfig}) → Stream/Generate
2
react.WithMessageFuture() → 观察中间步骤（无需 Callback）
3
host.NewMultiAgent({Host, Specialists}) → 调度型多 Agent
4
自定义 Graph + State → Plan-Execute / Deer-Go

一、ReAct Agent 基础

📁 flow/agent/react/

📖 官方文档：https://www.cloudwego.io/zh/docs/eino/core_modules/flow_integration_components/react_agent_manual/↗

1.1 ReAct 是什么

ReAct（Reasoning + Acting）是 Agent 的核心循环模式：

1
用户输入 → ChatModel 思考 → 需要调 Tool？
2
                              ├─ 是 → 执行 Tool → Tool 结果交还 ChatModel → 继续思考
3
                              └─ 否 → 输出最终答案

Eino 将这套循环封装为 react.NewAgent，一行创建，开箱即用。

1.2 最简示例：餐厅推荐

1
import (
2
    "github.com/cloudwego/eino/flow/agent/react"
3
    "github.com/cloudwego/eino/compose"
4
)
5

6
rAgent, err := react.NewAgent(ctx, &react.AgentConfig{
7
    ToolCallingModel: arkModel,
8
    ToolsConfig: compose.ToolsNodeConfig{
9
        Tools: []tool.BaseTool{restaurantTool, dishTool},
10
    },
11
})
12

13
// 流式调用（与 ChatModel.Stream 一样的 Recv+EOF 模式）
14
sr, _ := rAgent.Stream(ctx, []*schema.Message{
15
    schema.SystemMessage("你是一个帮助用户推荐餐厅的助手..."),
16
    schema.UserMessage("我在北京，推荐口味辣的菜，至少2家餐厅"),
17
})
18
defer sr.Close()
19

20
for {
21
    msg, err := sr.Recv()
22
    if errors.Is(err, io.EOF) { break }
23
    fmt.Print(msg.Content)
24
}

💡 这与入门笔记第三节的 ChatModelAgent + Runner 功能等效，但 react.NewAgent 暴露了更多底层控制点。

1.3 两个重要扩展点

MessageModifier：在每轮 ReAct 循环中注入 System Prompt：

1
react.NewAgent(ctx, &react.AgentConfig{
2
    MessageModifier: func(_ context.Context, input []*schema.Message) []*schema.Message {
3
        return append([]*schema.Message{schema.SystemMessage(sys)}, input...)
4
    },
5
})

StreamToolCallChecker：自定义 Tool 调用判断（某些模型不在第一个 chunk 返回 ToolCall）：

1
toolCallChecker := func(ctx context.Context, sr *schema.StreamReader[*schema.Message]) (bool, error) {
2
    defer sr.Close()
3
    for {
4
        msg, err := sr.Recv()
5
        if errors.Is(err, io.EOF) { break }
6
        if len(msg.ToolCalls) > 0 { return true, nil }
7
    }
8
    return false, nil
9
}

1.4 可视化调试：ExportGraph + Mermaid

1
anyG, opts := rAgent.ExportGraph()
2
gen := visualize.NewMermaidGenerator("flow/agent/react")
3
g := compose.NewGraph[[]*schema.Message, *schema.Message]()
4
g.AddGraphNode("react_agent", anyG, opts...)
5
g.AddEdge(compose.START, "react_agent")
6
g.AddEdge("react_agent", compose.END)
7
g.Compile(context.Background(), compose.WithGraphCompileCallbacks(gen))

二、Agentic ReAct Agent（Responses API 版）

📁 flow/agent/react/agentic/

2.1 核心差异点

维度	基础 ReAct	Agentic ReAct
模型	`model.BaseChatModel`	`model.AgenticModel`
消息	`*schema.Message`	`*schema.AgenticMessage`
工具节点	`compose.NewToolNode`	`compose.NewAgenticToolsNode`
分支判断	检查 `ToolCalls`	检查 `ContentBlocks` 中的 `FunctionToolCall`
服务端工具	❌	✅

2.2 关键创新：ToolReturnDirectly

1
config := &AgentConfig{
2
    Model: am,
3
    ToolsConfig: compose.ToolsNodeConfig{
4
        Tools: []tool.BaseTool{summarizeTool, locationTool},
5
    },
6
    ToolReturnDirectly: map[string]struct{}{
7
        "summarize_news": {},  // ← summarize_news 执行完直接结束
8
    },
9
}

2.3 按 ContentBlock 类型分别处理

1
msg, _ := schema.ConcatAgenticMessages(msgs)
2

3
for _, block := range msg.ContentBlocks {
4
    switch block.Type {
5
    case schema.ContentBlockTypeReasoning:
6
        fmt.Printf("[推理] %s\n", block.Reasoning.Text)
7
    case schema.ContentBlockTypeServerToolCall:
8
        fmt.Printf("[服务端工具] %s\n", block.ServerToolCall.Name)
9
    case schema.ContentBlockTypeAssistantGenText:
10
        fmt.Printf("[输出] %s\n", block.AssistantGenText.Text)
11
    }
12
}

三、短期记忆（Memory）

📁 flow/agent/react/memory_example/

3.1 MemoryStore 接口

1
type MemoryStore interface {
2
    Write(ctx, sessionID string, msgs []*schema.Message) error
3
    Read(ctx, sessionID string) ([]*schema.Message, error)
4
    Query(ctx, sessionID, text string, limit int) ([]*schema.Message, error)
5
}

实现	存储介质	适用场景
`InMemoryStore`	进程内存	开发/测试
`RedisStore`	Redis	生产环境

3.2 多轮对话模式

1
store := memory.NewInMemoryStore()
2
sessionID := "session:demo"
3

4
// 每轮对话
5
prev, _ := store.Read(ctx, sessionID)                          // 恢复历史
6
eff := append(prev, schema.UserMessage(turn))                  // 拼接新输入
7
sr, _ := agent.Stream(ctx, eff, msgFutureOpt)                  // 执行
8
_ = store.Write(ctx, sessionID, append(eff, produced...))      // 持久化

3.3 用 MessageFuture 观察中间步骤

1
msgFutureOpt, msgFuture := react.WithMessageFuture()
2

3
// 消费中间消息流
4
iter := msgFuture.GetMessageStreams()
5
for {
6
    sr, ok, _ := iter.Next()
7
    if !ok { break }
8
    full, _ := schema.ConcatMessages(readAllChunks(sr))
9
    fmt.Printf("中间消息: role=%s content=%s\n", full.Role, full.Content)
10
}

四、动态选项（Dynamic Option）

📁 flow/agent/react/dynamic_option_example/

4.1 痛点

ReAct Agent 在每轮迭代中使用相同的模型参数。但你可能希望第一轮开启思考模式，后续轮关闭思考。

4.2 核心机制：包装 ChatModel + ProcessState

1
type ChatModel struct {
2
    Model         model.BaseChatModel
3
    GetOptionFunc OptionFunc  // ← 根据 State 返回动态选项
4
}
5

6
func (d *ChatModel) Generate(ctx context.Context, input []*schema.Message, opts ...model.Option) (*schema.Message, error) {
7
    var dynamicOpts []model.Option
8

9
    compose.ProcessState[*State](ctx, func(_ context.Context, state *State) error {
10
        dynamicOpts = d.GetOptionFunc(ctx, input, state)
11
        state.Iteration++
12
        return nil
13
    })
14

15
    return d.Model.Generate(ctx, input, append(dynamicOpts, opts...)...)
16
}

4.3 动态选项函数示例

1
func getDynamicOptions(ctx context.Context, input []*schema.Message, state *State) []model.Option {
2
    if state.Iteration >= 1 {
3
        // 第二轮开始：关闭思考，禁止 Tool 调用
4
        return []model.Option{
5
            ark.WithThinking(&arkModel.Thinking{Type: arkModel.ThinkingTypeDisabled}),
6
            model.WithToolChoice(schema.ToolChoiceForbidden),
7
        }
8
    }
9
    // 第一轮：允许 Tool 调用
10
    return []model.Option{
11
        model.WithToolChoice(schema.ToolChoiceAllowed),
12
        model.WithTools(toolInfos),
13
    }
14
}

五、未知工具处理（Unknown Tool Handler）

📁 flow/agent/react/unknown_tool_handler_example/

1
rAgent, _ := react.NewAgent(ctx, &react.AgentConfig{
2
    ToolsConfig: compose.ToolsNodeConfig{
3
        Tools: []tool.BaseTool{sumTool},
4
        UnknownToolsHandler: func(ctx context.Context, name, input string) (string, error) {
5
            return fmt.Sprintf(
6
                "unknown tool: %s; try again with the correct tool name", name,
7
            ), nil
8
        },
9
    },
10
})

模型幻觉调用不存在的工具 → 不崩溃，返回提示 → 模型自纠错。

六、Multi-Agent：Host 模式

📁 flow/agent/multiagent/host/journal/

📖 官方文档：https://www.cloudwego.io/zh/docs/eino/core_modules/flow_integration_components/multi_agent_hosting/↗

6.1 概念

一个 Host（调度者） + 多个 Specialist（专家）：

1
用户 → Host（分析意图）
2
         ├─ "写日记" → WriteJournalSpecialist
3
         ├─ "读日记" → ReadJournalSpecialist
4
         └─ "查日记" → AnswerWithJournalSpecialist

6.2 完整实现

1
import "github.com/cloudwego/eino/flow/agent/multiagent/host"
2

3
h := &host.Host{ChatModel: chatModel, SystemPrompt: "..."}
4

5
hostMA, _ := host.NewMultiAgent(ctx, &host.MultiAgentConfig{
6
    Host: *h,
7
    Specialists: []*host.Specialist{writer, reader, answerer},
8
})
9

10
// 多轮对话
11
out, _ := hostMA.Stream(ctx, []*schema.Message{schema.UserMessage(input)},
12
    host.WithAgentCallbacks(cb),  // 可监听 HandOff 事件
13
)

6.3 与 ADK Supervisor 的对比

维度	Host MultiAgent（Flow）	Supervisor（ADK）
位置	`flow/agent/multiagent/host`	`adk/prebuilt/supervisor`
调度方式	Host ChatModel 决定派给谁	Supervisor Agent 决定派给谁
抽象层级	中低层（Compose Graph）	高层（ADK 封装）
适用	需要自定义 Specialist 结构	快速构建多 Agent 系统

七、Multi-Agent：Plan-Execute 模式

📁 flow/agent/multiagent/plan_execute/

7.1 概念

三阶段协作模式：

1
Planner（规划者）→ Executor（执行者）⇄ Reviser（审查者）
2
                                             ↓
3
                                    输出"最终答案" → END

7.2 核心配置

1
config := &Config{
2
    PlannerModel:  deepSeekModel,    // 规划者模型
3
    ExecutorModel: arkModel,         // 执行者模型（需支持 ToolCalling）
4
    ReviserModel:  deepSeekModel,    // 审查者模型
5
    ToolsConfig:   compose.ToolsNodeConfig{Tools: toolsConfig},
6
    MaxStep: 100,
7
}

💡 不同角色可以用不同的模型——Planner/Reviser 用便宜的推理模型，Executor 用支持 Tool Calling 的模型。

八、完整应用：Manus Agent

📁 flow/agent/manus/

8.1 概述

Manus Agent 展示了如何用 Compose Graph API 构建一个具备以下能力的 Agent：

🖥️ 命令行执行：Docker 沙箱中运行 Python 代码
🌐 浏览器操作：基于 Playwright 的网页浏览和交互
🔍 搜索引擎：DuckDuckGo 集成
👤 人类反馈：执行中断，等待用户确认后继续
📊 可观测性：Langfuse + CozeLoop 双追踪

8.2 Interrupt 驱动的人类反馈循环

1
for {
2
    result, err := agent.Invoke(ctx, input,
3
        compose.WithCheckPointID("1"),
4
        compose.WithRuntimeMaxSteps(20),
5
    )
6

7
    info, ok := compose.ExtractInterruptInfo(err)
8
    if ok {
9
        // 中断了——展示结果，等待用户确认
10
        fmt.Print("Do you want to continue? (y/n): ")
11
        // ... 读用户输入 ...
12
        continue  // 自动 Resume
13
    }
14
    fmt.Printf("[FinalResult]: %s", result)
15
    break
16
}

8.3 工具生态

1
// 命令行工具（Docker 沙箱）
2
sandbox.NewDockerSandbox(ctx, &sandbox.Config{...})
3

4
// 浏览器工具
5
browseruse.NewBrowserUseTool(ctx, &browseruse.Config{...})
6

7
// 搜索引擎
8
duckduckgo.NewSearch(ctx, &duckduckgo.Config{...})

九、完整应用：Deer-Go（研究团队协作）

📁 flow/agent/deer-go/

参考：https://github.com/bytedance/deer-flow↗

9.1 概述

Deer-Go 是一个基于状态图的多 Agent 研究团队，模拟真实的研究协作流程。

9.2 核心机制：State 驱动的子图流转

每个子图执行完毕后，改写 state.Goto 指定下一个要执行的 Agent：

1
func agentHandOff(ctx context.Context, input string) (next string, err error) {
2
    compose.ProcessState[*model.State](ctx, func(_ context.Context, state *model.State) error {
3
        next = state.Goto
4
        return nil
5
    })
6
    return next, nil
7
}
8

9
// 所有 Agent 节点共享同一个 Branch 函数
10
g.AddBranch(consts.Coordinator, compose.NewGraphBranch(agentHandOff, outMap))
11
g.AddBranch(consts.Planner, compose.NewGraphBranch(agentHandOff, outMap))

9.3 团队组成

1
Coordinator → BackgroundInvestigator → Planner → ResearchTeam
2
                                                      ├─→ Researcher
3
                                                      ├─→ Coder
4
                                                      └─→ Planner（迭代）
5
                                                           └─→ Reporter → Human → Coordinator

十、示例导航

目录	主题	核心知识点	复杂度
`react/`	ReAct Agent 基础	`react.NewAgent`, Stream, ExportGraph	⭐
`react/agentic/`	Agentic ReAct	Graph 自定义 ReAct, ToolReturnDirectly	⭐⭐⭐
`react/memory_example/`	短期记忆	MemoryStore 接口, MessageFuture	⭐⭐
`react/dynamic_option_example/`	动态选项	ChatModel 包装, ProcessState	⭐⭐⭐
`react/unknown_tool_handler_example/`	未知工具	UnknownToolsHandler	⭐
`multiagent/host/journal/`	Host Multi-Agent	Host + Specialist, HandOff 回调	⭐⭐
`multiagent/plan_execute/`	Plan-Execute	Planner→Executor⇄Reviser	⭐⭐⭐
`manus/`	Manus Agent	Docker 沙箱, 浏览器, Interrupt+Resume	⭐⭐⭐⭐
`deer-go/`	Deer-Go 研究团队	状态图流转, 多子图协作, Goto 驱动	⭐⭐⭐⭐

常用 import 路径

1
// ReAct Agent
2
"github.com/cloudwego/eino/flow/agent/react"           // react.NewAgent, WithMessageFuture
3

4
// Multi-Agent
5
"github.com/cloudwego/eino/flow/agent/multiagent/host"  // host.NewMultiAgent, Host, Specialist
6

7
// Compose 底层
8
"github.com/cloudwego/eino/compose"                     // Graph, Branch, ProcessState, ToolNode
9
"github.com/cloudwego/eino/schema"                      // Message, AgenticMessage, ToolInfo
10

11
// Callbacks
12
"github.com/cloudwego/eino/callbacks"                   // Handler, HandlerBuilder
13
"github.com/cloudwego/eino/utils/callbacks"              // NewHandlerHelper

📇 本附录速记卡片

1
Flow 模块核心方法：
2
  react.NewAgent({ToolCallingModel, ToolsConfig})
3
  host.NewMultiAgent({Host, Specialists})
4
  compose.NewGraphBranch(fn, outMap)
5
  compose.ProcessState[T](ctx, fn) — 读写 Graph State
6

7
选型：标准→ADK | 自定义循环→react | 多Agent调度→host | 状态图→Graph+State

📂 源码仓库：github.com/cloudwego/eino-examples↗

📖 继续阅读：

入门笔记 — Eino ADK 从 Hello World 到 Compose 编排

Agentic 进阶 — Responses API / AgenticMessage / Typed 泛型

附录一：Flow 流程模块 — ReAct Agent / Multi-Agent / 状态图 ← 你在这里

附录二：Components 组件模块 — A/B 路由 / HTTP 日志 / 检索增强 / 文档解析

附录三：Lambda 与调试工具 — Lambda 写法 / Devops / Mermaid 可视化

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://muxiaowf.dpdns.org/blog/260720eino-appendix1/

Eino学习笔记 —— 附录2

MuxiaoWF — Mon, 20 Jul 2026 00:00:00 GMT

本笔记通过ai辅助生成，但对于代码阅读顺序应当没有问题（均使用eino官方的例子进行，个人认为官方的教程感觉有点太难懂了）

理论上个人感觉附录只做了解即可，需要时可进行查询

附录二：Components 组件模块

📂 源码仓库：github.com/cloudwego/eino-examples↗

📖 系列文档：入门笔记 | Agentic 进阶 | 附录一 Flow | 附录二组件 | 附录三工具

📁 代码根目录：components/

📖 前置知识：本附录聚焦 Eino 的可替换组件——Model（模型）、Retriever（检索器）、Document Parser（文档解析器）。这些组件实现统一接口，可在 Graph/Agent/Runner 中自由插拔。

速览：组件体系概述

Eino 的组件层是所有上层抽象（ADK、Flow、Compose）的积木块。每个组件类型定义了一个标准接口，不同实现可以无缝替换：

1
┌─────────────────────────────────────────┐
2
│         ADK / Flow / Compose            │  ← 上层编排
3
├─────────────────────────────────────────┤
4
│  ChatModel │ Retriever │ Parser │ ...   │  ← 组件接口
5
├─────────────────────────────────────────┤
6
│  OpenAI │ ARK │ VikingDB │ PDF │ HTML   │  ← 具体实现
7
└─────────────────────────────────────────┘

📇 本附录速记卡片

1
组件层三大类：
2
  Model:    A/B 路由（ABRouter）/ HTTP 日志（CurlRT）
3
  Retriever: Multi-Query（改写查询）/ Router（多数据源路由）
4
  Parser:   TextParser → ExtParser → CustomParser（按扩展名分发）
5

6
核心模式：全都实现统一接口 → 可在任何编排中自由插拔

一、Model：A/B 测试路由

📁 components/model/abtest/

1.1 这东西解决什么问题？

相信有数分基础的对这个肯定很熟悉

假设你写了一个 Agent，用的是 GPT-4o。现在团队新接入了 DeepSeek，便宜 80% 但质量可能稍差。你敢直接全量切过去吗？

不敢。 你希望的是：

1
100% 用户请求
2
  ├─ 90% → GPT-4o（主力，稳定）
3
  └─ 10% → DeepSeek（实验，观察）

跑一周后对比两组用户的满意度、延迟、成本——数据说话，决定切不切。这就是 A/B 测试。

ABRouterChatModel 就是这个”流量分配器”——对外和普通 ChatModel 一模一样，但内部根据你写的规则把请求分给不同模型。

1.2 完整示例

1
import "github.com/cloudwego/eino-examples/components/model/abtest"
2

3
// 准备两个候选模型
4
gpt4o, _ := openai.NewChatModel(ctx, &openai.ChatModelConfig{...})
5
deepseek, _ := openai.NewChatModel(ctx, &openai.ChatModelConfig{
6
    BaseURL: "https://api.deepseek.com/v1",  // 指向 DeepSeek
7
    Model:   "deepseek-chat",
8
})
9

10
// 路由器：根据 userID 最后一位做 A/B 分流
11
router := abtest.NewABRouterChatModel(func(
12
    ctx context.Context, in []*schema.Message, _ ...model.Option,
13
) (string, model.BaseChatModel, error) {
14
    // 从 context 中提取 userID（实际项目中从请求上下文拿）
15
    userID, _ := ctx.Value("userID").(string)
16
    if userID != "" && userID[len(userID)-1] < '5' {  // 50% 流量
17
        return "deepseek", deepseek, nil  // 实验组
18
    }
19
    return "gpt4o", gpt4o, nil            // 对照组
20
})
21

22
// 使用方式和普通 ChatModel 完全一样！
23
msg, _ := router.Generate(ctx, messages)

1.3 不止 A/B 测试——三种实际应用场景

场景	路由规则	目的
A/B 测试	userID hash → 10% 新模型，90% 旧模型	对比效果后决定是否全量切换
成本优化	消息长度 < 100 → 便宜模型；≥ 100 → 强模型	简单问题不需要大炮打蚊子
灰度发布	1% 流量 → 新模型；观测一天无异常 → 5% → 20% → 100%	逐步放量，出问题快速回滚

🧠 关键理解：ABRouter 的关键价值是对外接口不变——你的 Agent 代码不需要知道底层有几个模型在跑，改路由规则不需要改业务代码。

二、Model：HTTP 传输日志（cURL 风格调试）

📁 components/model/httptransport/

2.1 这东西解决什么问题？

你写了一个 Agent，跑起来后 LLM 返回了奇怪的结果。你想确认：

真正发给 API 的请求长什么样？（prompt 有没有被截断？参数对不对？）
API 返回的原始响应是什么？（是不是 JSON 解析出了问题？）
能不能把请求复制成 cURL 命令，在终端里重放？

httptransport 就是做这个的——它拦截所有 HTTP 请求/响应，以可直接复制的 cURL 命令格式打印日志，同时自动脱敏 API Key。

2.2 核心机制

1
client := &http.Client{
2
    Transport: httptransport.NewCurlRT(
3
        http.DefaultTransport,          // 基础 Transport（真正发请求的）
4
        httptransport.WithLogger(log.Default()),
5
        httptransport.WithPrintAuth(false),              // ⚠️ API Key 脱敏（默认不打印）
6
        httptransport.WithMaskHeaders([]string{"X-API-KEY"}),
7
        httptransport.WithStreamLogging(true),            // 流式响应也记录
8
        httptransport.WithMaxStreamLogBytes(8192),
9
    ),
10
}
11

12
// 注入到 ChatModel — 之后调用时自动打印日志
13
chatModel, _ := openai.NewChatModel(ctx, &openai.ChatModelConfig{
14
    HTTPClient: client,
15
})

2.3 日志输出效果

请求日志——直接复制到终端就能重放：

1
[curl request] curl -X POST 'https://api.openai.com/v1/chat/completions' \
2
  -H 'Content-Type: application/json' \
3
  -H 'Authorization: <redacted>' \
4
  --data '{"model":"gpt-4o","messages":[{"role":"user","content":"hello"}]}'

响应日志——看到 API 返回的原始 JSON：

1
[curl response] HTTP/1.1 200
2
{"id":"chatcmpl-xxx","choices":[{"message":{"role":"assistant","content":"Hello! How can I help?"}}]}

2.4 配置速查

选项	作用	默认值
`WithPrintAuth(false)`	不打印 Authorization Header	脱敏
`WithMaskHeaders(...)`	额外脱敏的 Header	—
`WithStreamLogging(true)`	流式响应逐 chunk 记录	不记录
`WithMaxStreamLogBytes(n)`	流式日志最大字节数	8192
`WithCtxLogger(...)`	从 ctx 提取 request ID 注入日志	—

🧠 关键理解：这是一个调试/排障工具，不是生产必用的。建议开发时开着，生产环境关闭或只在采样流量中开启。

三、Retriever：多查询检索（Multi-Query）

📁 components/retriever/multiquery/

3.1 这东西解决什么问题？

在 RAG（检索增强生成）场景中，用户的查询往往不够精确：

1
用户输入: "怎么提高代码质量"
2
向量库里相关文档的标题实际是:
3
  "单元测试最佳实践"
4
  "Code Review 流程规范"
5
  "静态分析工具配置指南"

直接拿”怎么提高代码质量”去向量检索，可能什么都搜不到——用户的口语和文档的专业术语之间有语义鸿沟。

Multi-Query 的解决思路：先让 LLM 把用户的话翻译成 3 个不同角度的查询，每个都去搜一遍，结果合并去重。

3.2 工作流程

1
用户输入: "tourist attraction"（太模糊）
2
    ↓ LLM 自动改写
3
变体1: "best tourist attractions for families"     ← 从"亲子"角度
4
变体2: "outdoor sightseeing spots recommendations"  ← 从"户外"角度
5
变体3: "popular travel destinations and landmarks"  ← 从"知名景点"角度
6
    ↓ 分别检索同一向量库
7
结果1: [doc_a, doc_b]
8
结果2: [doc_b, doc_d]     →  FusionFunc 合并去重 → [doc_a, doc_b, doc_c, doc_d, doc_e, doc_f]
9
结果3: [doc_c, doc_e, doc_f]

3.3 完整实现

1
import "github.com/cloudwego/eino/flow/retriever/multiquery"
2

3
mqr, _ := multiquery.NewRetriever(ctx, &multiquery.Config{
4
    RewriteHandler: func(ctx context.Context, query string) ([]string, error) {
5
        out, _ := llm.Generate(ctx, []*schema.Message{
6
            schema.SystemMessage("Generate 3 rewritten search queries, one per line."),
7
            schema.UserMessage(query),
8
        })
9
        return strings.Split(out.Content, "\n"), nil
10
    },
11
    MaxQueriesNum: 3,        // 最多生成 3 个变体
12
    OrigRetriever: vk,        // 底层向量检索引擎
13
})
14

15
docs, _ := mqr.Retrieve(ctx, "tourist attraction")
16
// docs 包含所有变体的合并结果

🧠 关键理解：Multi-Query 是”用 LLM 做查询增强”——用便宜的、快速的模型做改写，拿改写结果去向量库搜。FusionFunc 默认按文档 ID 去重，保留第一次出现的顺序。

四、Retriever：路由检索（Router）

📁 components/retriever/router/

4.1 这东西解决什么问题？

Multi-Query 解决的是”一个知识库里搜不准”的问题。Router 解决的是”多个知识库，不知道该搜哪个”的问题。

1
你的系统有三个向量库:
2
  product_vdb  → 存商品信息（名称、价格、规格）
3
  review_vdb   → 存用户评价（打分、评论文本）
4
  faq_vdb      → 存常见问题（Q&A 对）
5

6
用户问"这个商品多少钱？" → 搜 product_vdb
7
用户问"这个商品好用吗？" → 搜 review_vdb
8
用户问"怎么退货？"      → 搜 faq_vdb

Router Retriever 就是声明”有哪些库 + 什么样的查询走哪个库”，一次调用自动路由+合并。

4.2 完整实现

1
rr, _ := router.NewRetriever(ctx, &router.Config{
2
    Retrievers: map[string]retriever.Retriever{
3
        "product":  productRetriever,   // 商品向量库
4
        "review":   reviewRetriever,    // 评价向量库
5
        "faq":      faqRetriever,       // FAQ 向量库
6
    },
7
    Router: func(ctx context.Context, query string) ([]string, error) {
8
        var targets []string
9
        // 按关键词路由到不同引擎
10
        if strings.Contains(query, "价格") || strings.Contains(query, "规格") {
11
            targets = append(targets, "product")
12
        }
13
        if strings.Contains(query, "评价") || strings.Contains(query, "好用") {
14
            targets = append(targets, "review")
15
        }
16
        if strings.Contains(query, "退货") || strings.Contains(query, "怎么") {
17
            targets = append(targets, "faq")
18
        }
19
        if len(targets) == 0 {
20
            targets = []string{"product", "review", "faq"}  // 兜底：全搜
21
        }
22
        return targets, nil
23
    },
24
    FusionFunc: nil,  // nil = 默认 RRF（Reciprocal Rank Fusion）融合
25
})

4.3 与 Multi-Query 的区别

维度	Multi-Query	Router
解决什么问题	用户说的话太模糊，向量库搜不准	有多个向量库，不知道该搜哪个
检索次数	N 个变体 ×1 个检索器 = N 次	M 个选中检索器 × 1 次 = M 次
核心思路	用 LLM 改写查询，多角度搜	分析查询内容，分派到对应库
适用	单一知识库，提升召回率	多知识库，联合检索

💡 两者可以组合——先 Router 到多个检索器，每个检索器再 Multi-Query 改写，然后全局融合。

五、Document Parser

5.1 文本解析器（最简入口）

1
import "github.com/cloudwego/eino/components/document/parser"
2

3
textParser := parser.TextParser{}
4
docs, _ := textParser.Parse(ctx, strings.NewReader("hello world"))

5.2 ExtParser：按文件扩展名自动选择解析器

动机：你上传的文件可能是 HTML、PDF、Markdown 或纯文本。写一堆 if/switch 太麻烦。ExtParser 根据文件后缀自动分发给对应的 Parser：

1
extParser, _ := parser.NewExtParser(ctx, &parser.ExtParserConfig{
2
    Parsers: map[string]parser.Parser{
3
        ".html": htmlParser,     // → 用 CSS Selector 提取 body 内容
4
        ".pdf":  pdfParser,      // → 用 PDF 解析引擎提取文本
5
    },
6
    FallbackParser: textParser,  // 未知格式 → 当纯文本读
7
})
8

9
file, _ := os.Open("./testdata/test.html")
10
docs, _ := extParser.Parse(ctx, file, parser.WithURI(filePath))
11
// ↑ WithURI 必须传——ExtParser 靠文件路径后缀判断格式

5.3 自定义 Parser（四步实现）

当内置的 TextParser / HTML / PDF 不满足需求时（比如解析 Word 文档、Excel 表格、自定义格式）：

定义自定义选项结构体 (type options struct{...})
用 parser.WrapImplSpecificOptFn 创建 Option 函数
定义 Config + 结构体 + 构造函数
实现 Parse(ctx, io.Reader, ...parser.Option) ([]*schema.Document, error)

核心技巧：

parser.GetCommonOptions() 提取框架通用选项（WithURI, WithExtraMeta）
parser.GetImplSpecificOptions() 提取自定义选项
parser.WrapImplSpecificOptFn 将自定义 func(*options) 包装成 parser.Option

六、全景速查

组件类型	解决什么问题	章节	核心 API
ABRouter	新模型不敢全量切 → 按规则分流量 A/B 对比	一	`NewABRouterChatModel(routerFn)`
CurlRT	API 调崩了不知道发了什么 → cURL 风格日志调试	二	`NewCurlRT(transport, opts...)`
Multi-Query	用户搜得太模糊 → LLM 改写 N 个变体分别搜	三	`multiquery.NewRetriever({RewriteHandler, OrigRetriever})`
Router Retriever	多个向量库不知搜哪个 → 按查询内容自动路由	四	`router.NewRetriever({Retrievers, Router})`
ExtParser	多种文档格式 → 按扩展名自动分发	五	`NewExtParser({Parsers: map[".ext"]parser})`

常用 import 路径

1
// A/B 测试路由
2
"github.com/cloudwego/eino-examples/components/model/abtest"
3

4
// HTTP 传输日志
5
"github.com/cloudwego/eino-examples/components/model/httptransport"
6

7
// 检索器增强
8
"github.com/cloudwego/eino/flow/retriever/multiquery"   // Multi-Query
9
"github.com/cloudwego/eino/flow/retriever/router"        // Router
10

11
// 文档解析器
12
"github.com/cloudwego/eino/components/document/parser"         // Parser 接口, TextParser, ExtParser
13
"github.com/cloudwego/eino-ext/components/document/parser/html" // HTML
14
"github.com/cloudwego/eino-ext/components/document/parser/pdf"  // PDF

分层架构回顾

1
┌──────────────────────────────────────────────────┐
2
│  ADK 层（入门笔记 §1~§7）                           │
3
│  ChatModelAgent, Runner, Middleware, Interrupt   │
4
├──────────────────────────────────────────────────┤
5
│  Flow 层（附录一：Flow 流程模块）                    │
6
│  react.NewAgent, host.NewMultiAgent              │
7
├──────────────────────────────────────────────────┤
8
│  Compose 层（入门笔记 §6.4）                        │
9
│  Graph, Chain, Workflow, Branch, ProcessState    │
10
├──────────────────────────────────────────────────┤
11
│  组件层（本附录）                                   │
12
│  ChatModel, Retriever, Parser, Tool              │
13
└──────────────────────────────────────────────────┘

📇 本附录速记卡片

1
Model:
2
  ABRouter = 流量分配器（A/B测试 / 成本优化 / 灰度发布）
3
  CurlRT   = HTTP 调试器（cURL风格日志 + API Key 自动脱敏）
4

5
Retriever:
6
  MultiQuery = 用 LLM 改写查询 → 多角度搜同一个库 → 合并去重
7
  Router     = 分析查询内容 → 分派到不同库 → 结果融合
8

9
Parser:
10
  TextParser → ExtParser(按扩展名映射) → CustomParser(WrapImplSpecificOptFn)

📂 源码仓库：github.com/cloudwego/eino-examples↗

📖 继续阅读：

入门笔记 — Eino ADK 从 Hello World 到 Compose 编排

Agentic 进阶 — Responses API / AgenticMessage / Typed 泛型

附录一：Flow 流程模块 — ReAct Agent / Multi-Agent / 状态图

附录二：Components 组件模块 — A/B 路由 / HTTP 日志 / 检索增强 / 文档解析 ← 你在这里

附录三：Lambda 与调试工具 — Lambda 写法 / Devops / Mermaid 可视化

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://muxiaowf.dpdns.org/blog/260720eino-appendix2/

Eino学习笔记 —— 附录3

MuxiaoWF — Mon, 20 Jul 2026 00:00:00 GMT

本笔记通过ai辅助生成，但对于代码阅读顺序应当没有问题（均使用eino官方的例子进行，个人认为官方的教程感觉有点太难懂了）

理论上个人感觉附录只做了解即可，需要时可进行查询

附录三：Lambda 写法、调试工具与可视化

📂 源码仓库：github.com/cloudwego/eino-examples↗

📖 系列文档：入门笔记 | Agentic 进阶 | 附录一 Flow | 附录二组件 | 附录三工具

📁 代码根目录：components/lambda/、devops/

📖 前置知识：Lambda 是 Compose 编排中最灵活的节点类型；调试和可视化是开发和排障的必备工具。

速览：三种工具的关系

1
开发阶段                              生产阶段
2
────────                              ────────
3
Lambda 写业务逻辑
4
    ↓
5
Graph/Chain 编排节点
6
    ↓
7
可视化（Mermaid）                     调试（Devops）
8
查看拓扑结构                          图形界面测试
9
    ↓
10
确认结构无误                          确认逻辑无误
11
    ↓
12
    提交代码 → 生产运行

📇 本附录速记卡片

1
Lambda 四种创建：
2
  InvokableLambda(fn)                     ← 最简
3
  InvokableLambdaWithOption(fn)           ← 需自定义参数
4
  AnyLambda(invoke, stream, collect, transform) ← 全模式
5
  ToList[T]()                             ← 类型转换 T→[]T
6

7
调试：devops.Init(ctx) → Chain/Graph.Compile → 图形界面测试
8
可视化：NewMermaidGenerator(dir) → Compile(WithGraphCompileCallbacks(gen))

一、Lambda 节点写法大全

📁 components/lambda/lambda.go

📖 官方文档：https://www.cloudwego.io/zh/docs/eino/core_modules/components/lambda_guide/↗

1.1 Lambda 是什么

Lambda 是 Compose 编排中的”万能节点”——你可以把任意 Go 函数包装成 Graph/Chain 的一个节点：

1
Graph 内置节点：ChatModel、ToolsNode、ChatTemplate  ← 框架提供
2
Lambda 节点：    你写的任意函数                       ← 你自己提供

1.2 Lambda 决策树

1
你需要什么？
2
│
3
├─ 最简单：ctx+input → output
4
│   └─→ compose.InvokableLambda(fn)
5
│
6
├─ 需要自定义参数
7
│   └─→ compose.InvokableLambdaWithOption(fn)
8
│
9
├─ 需要流式处理（Stream/Transform）
10
│   └─→ compose.AnyLambda(invoke, stream, collect, transform)
11
│
12
├─ 只做类型转换 T → []T
13
│   └─→ compose.ToList[T]()
14
│
15
└─ 解析 ChatModel 返回的 JSON
16
    └─→ compose.MessageParser(parser)

1.3 四种创建方式

方式一：InvokableLambda（最简）

1
lambda := compose.InvokableLambda(
2
    func(ctx context.Context, input string) (output string, err error) {
3
        return strings.ToUpper(input), nil
4
    },
5
)

方式二：InvokableLambdaWithOption（带自定义参数）

1
type Options struct { Field1 string }
2
type MyOption func(*Options)
3

4
lambda := compose.InvokableLambdaWithOption(
5
    func(ctx context.Context, input string, opts ...MyOption) (output string, err error) {
6
        o := &Options{}
7
        for _, opt := range opts { opt(o) }
8
        return "", nil
9
    },
10
)

方式三：AnyLambda（全功能：Invoke/Stream/Collect/Transform）

1
lambda, _ := compose.AnyLambda(
2
    func(ctx context.Context, input string, opts ...MyOption) (output string, err error) { return "", nil },
3
    func(ctx context.Context, input string, opts ...MyOption) (output *schema.StreamReader[string], err error) { return nil, nil },
4
    func(ctx context.Context, input *schema.StreamReader[string], opts ...MyOption) (output string, err error) { return "", nil },
5
    func(ctx context.Context, input *schema.StreamReader[string], opts ...MyOption) (output *schema.StreamReader[string], err error) { return nil, nil },
6
)

方式四：ToList（类型转换 Lambda）

1
// ChatModel 返回 *schema.Message，下游需要 []*schema.Message 时桥接
2
chain.AppendLambda(compose.ToList[*schema.Message]())

1.4 Lambda 在 Chain 和 Graph 中的使用

1
// Chain
2
chain := compose.NewChain[string, string]()
3
chain.AppendLambda(
4
    compose.InvokableLambda(func(ctx context.Context, input string) (string, error) {
5
        return input + " processed", nil
6
    }),
7
    compose.WithNodeName("step1"),
8
)
9

10
// Graph
11
graph := compose.NewGraph[string, *MyStruct]()
12
graph.AddLambdaNode("node1",
13
    compose.InvokableLambda(func(ctx context.Context, input string) (*MyStruct, error) {
14
        return &MyStruct{ID: 1}, nil
15
    }),
16
    compose.WithStatePreHandler(func(ctx context.Context, input string, state *myState) (string, error) {
17
        return input, nil  // 节点执行前读写 State
18
    }),
19
)

1.5 特殊类型 Lambda：MessageParser

将 *schema.Message 的 Content（JSON 字符串）解析成 Go 结构体：

1
parser := schema.NewMessageJSONParser[*MyStruct](&schema.MessageJSONParseConfig{
2
    ParseFrom: schema.MessageParseFromContent,
3
})
4
parserLambda := compose.MessageParser(parser)
5

6
chain := compose.NewChain[*schema.Message, *MyStruct]()
7
chain.AppendLambda(parserLambda)

二、Eino Devops 调试工具

📁 devops/debug/

2.1 启动调试服务

1
import (
2
    "github.com/cloudwego/eino-ext/devops"
3
    "os/signal"
4
    "syscall"
5
)
6

7
func main() {
8
    err := devops.Init(ctx)  // 1. 启动 HTTP 调试界面
9

10
    chain.RegisterSimpleChain(ctx)     // 2. 注册你的 Chain/Graph
11
    graph.RegisterSimpleGraph(ctx)
12

13
    sigs := make(chan os.Signal, 1)   // 3. 阻塞等待
14
    signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
15
    <-sigs
16
}

💡 devops.Init(ctx) 只需调用一次。注册的 Chain/Graph 会出现在调试界面的下拉菜单中。

2.2 Any 类型输入的调试技巧

当 Graph 的输入类型是 map[string]any 时，需要附带类型标注：

1
{
2
    "name": {
3
        "_value": "alice",
4
        "_eino_go_type": "string"
5
    },
6
    "score": {
7
        "_value": "99",
8
        "_eino_go_type": "int"
9
    }
10
}

三、可视化工具：Mermaid 图表生成

📁 devops/visualize/mermaid.go

3.1 基础用法

1
import "github.com/cloudwego/eino-examples/devops/visualize"
2

3
gen := visualize.NewMermaidGenerator("output/dir")  // 指定输出目录
4

5
runner, _ := g.Compile(context.Background(),
6
    compose.WithGraphCompileCallbacks(gen),
7
    compose.WithGraphName("MyGraph"),
8
)

输出文件：output/dir/MyGraph（Markdown）+ MyGraph.png（自动渲染的拓扑图）。

3.2 可视化规则

节点类型	Mermaid 形状
START / END	`([START])` `([END])` 圆角矩形
普通节点	`[节点名<br/>(组件类型)]` 方框
Lambda 节点	`(节点名<br/>(Lambda))` 圆角方框
嵌套子图	`subgraph ... end` 子图框
Branch 分支	`{"branch"}` 菱形

3.3 图片生成策略

优先 mmdc（Mermaid CLI）：mmdc -i input.mmd -o output.png
降级 chromedp：无头浏览器渲染 SVG → 截图保存为 PNG

四、Lambda 速查表

类型	创建函数	必备参数	常用选项
纯函数 Lambda	`compose.InvokableLambda(fn)`	fn	—
带选项 Lambda	`compose.InvokableLambdaWithOption(fn)`	fn	自定义 Option
全模式 Lambda	`compose.AnyLambda(invoke, stream, collect, transform)`	4 个函数	自定义 Option
列表包装	`compose.ToList[T]()`	—（泛型）	—
消息解析	`compose.MessageParser(parser)`	schema.MessageJSONParser	—

常用 import 路径

1
// Lambda
2
"github.com/cloudwego/eino/compose"  // InvokableLambda, AnyLambda, ToList, MessageParser
3
"github.com/cloudwego/eino/schema"   // NewMessageJSONParser, MessageParseFromContent
4

5
// 调试
6
"github.com/cloudwego/eino-ext/devops"  // Init
7

8
// 可视化
9
"github.com/cloudwego/eino-examples/devops/visualize"  // NewMermaidGenerator

全系列文档索引

文档	内容	定位
入门笔记	ADK 入门 + Middleware + Interrupt + Compose 概览	🌱 入门
Agentic 进阶	AgenticModel / AgenticMessage / Typed 体系 / 截断重试	🌿 进阶
附录一：Flow 流程模块	Flow 模块：ReAct / Multi-Agent / 状态图 / Manus / Deer-Go	🌳 深度
附录二：Components 组件模块	组件模块：A/B 路由 / HTTP 日志 / 检索增强 / 文档解析	🔧 组件
附录三：Lambda 与调试工具	Lambda 写法 / Devops 调试 / Mermaid 可视化	🛠️ 工具

📇 本附录速记卡片

1
Lambda:     InvokableLambda（ctx+T→T）→ AppendLambda / AddLambdaNode
2
调试:       devops.Init → Compile → 图形界面测试
3
可视化:     NewMermaidGenerator → WithGraphCompileCallbacks →  + .png
4
MessageParser:  ChatModel JSON 输出 → Go 结构体（类型安全处理）

📂 源码仓库：github.com/cloudwego/eino-examples↗

📖 继续阅读：

入门笔记 — Eino ADK 从 Hello World 到 Compose 编排

Agentic 进阶 — Responses API / AgenticMessage / Typed 泛型

附录一：Flow 流程模块 — ReAct Agent / Multi-Agent / 状态图

附录二：Components 组件模块 — A/B 路由 / HTTP 日志 / 检索增强 / 文档解析

附录三：Lambda 与调试工具 — Lambda 写法 / Devops / Mermaid 可视化 ← 你在这里

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://muxiaowf.dpdns.org/blog/260720eino-appendix3/

Eino学习笔记

MuxiaoWF — Mon, 20 Jul 2026 00:00:00 GMT

本笔记通过ai辅助生成，但对于代码阅读顺序应当没有问题（均使用eino官方的例子进行，个人认为官方的教程感觉有点太难懂了）

另附，可能是更新速度快，部分代码的方法已经被标记为废弃，但在示例中仍然未修改为最新的方法，建议自行对应

Eino 框架学习笔记

📂 源码仓库：github.com/cloudwego/eino-examples↗

📖 系列文档：入门笔记 | Agentic 进阶 | 附录一 Flow | 附录二组件 | 附录三工具

速览：两条调用路径 & 核心速记

在深入细节之前，先在心里放一张总地图。Eino 只有两条调用路径：

sequenceDiagram
    actor U as 用户代码
    participant CM as ChatModel
    participant A as Agent
    participant R as Runner
    participant I as Iterator

    Note over U,I: === 轻量路径：直接用 ChatModel（入门笔记 §2） ===
    U->>CM: Generate(messages) / Stream(messages)
    CM-->>U: *schema.Message / StreamReader

    Note over U,I: === 完整路径：Agent + Runner（入门笔记 §3~§5） ===
    U->>CM: ① NewChatModel(config)
    CM-->>U: model
    U->>A: ② NewChatModelAgent(model, instruction, tools)
    A-->>U: agent
    U->>R: ③ NewRunner(agent, streaming, checkpoint)
    R-->>U: runner
    U->>R: ④ Run(input) / Query(input, checkpointID)
    R-->>I: AsyncIterator[*AgentEvent]
    loop 消费事件
        I->>I: Next() → (event, ok)
    end

    Note over U,I: === Agentic 路径：Responses API（Agentic 进阶） ===
    U->>CM: ① New(agenticModel)
    CM-->>U: model
    U->>A: ② NewTypedChatModelAgent[*AgenticMessage](model, ...)
    A-->>U: agent
    U->>R: ③ NewTypedRunner[*AgenticMessage](agent, ...)
    R-->>U: runner
    U->>R: ④ Run(AgenticMessage输入)
    R-->>I: Iterator
    loop 消费事件
        I->>I: TypedGetMessage(event) → msg.String()
    end

📇 全篇速记卡片（看完这篇你只需要记住这些）

1
创建链：NewChatModel → NewChatModelAgent → NewRunner → Run
2
           (模)            (代)             (跑)       (消息)
3

4
两种迭代：Agent 用 Next() → (event, ok) —— !ok 结束
5
          Stream 用 Recv() → (chunk, err) —— io.EOF 结束
6

7
Agent 管能力：{Name, Instruction, ToolsConfig, Model}
8
Runner 管执行：{Agent, EnableStreaming, CheckPointStore}
9

10
三种 Tool 创建：90% 用 InferTool(函数+struct tag)
11
              需要约束用 NewTool(schema+函数)
12
              有状态用结构体实现接口
13

14
中断恢复三要素：CheckPointStore + CheckPointID + Resume
15

16
核心包（按使用频率）：
17
  github.com/cloudwego/eino/adk        ← Agent, Runner, Message
18
  github.com/cloudwego/eino/schema      ← UserMessage, SystemMessage
19
  github.com/cloudwego/eino/components/tool/utils  ← InferTool, NewTool
20
  github.com/cloudwego/eino-ext/components/model/openai  ← ChatModel

⚡ 关键概念：Iterator（事件迭代器）是什么？

在所有 Eino 示例中，runner.Run() 和 runner.Query() 都会立即返回一个 AsyncIterator[*AgentEvent]（简称 Iterator），然后你通过 Next() 逐个消费事件。这是 Eino 最核心的数据消费模式。

为什么要有 Iterator？

Agent 执行是异步的：模型调用可能耗时几秒到几十秒，期间可能经历”思考→调Tool→再思考→输出文本”多个阶段。如果 Run() 等全部完成才返回，你的程序就卡住了。

Iterator 解决了这个问题——立即返回一个”事件管道”，Agent 在后台生成事件、推入管道，你在前台逐个取出处理。类比：

1
Runner.Run() 返回 Iterator = 你拿到一个"对讲机"
2
Agent 在后台干活，每隔一会通过对讲机说句话
3
你在前台: Next() → 收到一条消息 → Next() → 收到下一条 → ...
4
Next() 返回 (event, false) = 对讲机没信号了 = Agent 干完了

Iterator 的本质

1
type AsyncIterator[T any] struct {
2
    // 内部有 channel，连接"生产者"（Agent goroutine）和"消费者"（你的代码）
3
}
4

5
func (iter *AsyncIterator[T]) Next() (item T, ok bool) {
6
    // 阻塞等待下一个事件
7
    // ok=true: 拿到了新事件
8
    // ok=false: 管道关闭，Agent 执行完毕
9
}

与 Go channel 的对比

	Go channel	AsyncIterator
创建	`make(chan T)`	Runner.Run() / Runner.Query() 返回
发送	`ch <- item`	Agent 内部通过 `gen.Send(event)`
接收	`item := <-ch`	`event, ok := iter.Next()`
关闭	`close(ch)`	Agent 内部通过 `gen.Close()`
关闭检测	`item, ok := <-ch`	`event, ok := iter.Next()` — 同样是 ok=false

🧠 一句话：Iterator 就是包装了 channel 的”事件流”——Agent 在后台往里面写事件，你在前台用 Next() 逐个读。读完（ok=false）Agent 就结束了。

一、Hello World：认识四步组装线

📁 代码：adk/helloworld/helloworld.go

为什么这样设计？

Eino 把一个 AI 对话应用拆成四个独立零件，像组装流水线一样逐个创建、最后拼起来运行。这样拆的好处是：每个零件可以单独替换（比如换个模型、换个 Agent 类型），互不影响。

四步组装线（记忆口诀：“模→代→跑→消息”）

1
第1步 创建 ChatModel     →  第2步 创建 Agent     →  第3步 创建 Runner     →  第4步 发送消息并运行
2
（"嘴巴"，负责调用LLM）      （"大脑"，封装业务逻辑）    （"引擎"，管理执行过程）      （用户说的话）

示范代码（带注释）

1
package main
2

3
import (
4
    "context"
5
    "fmt"
6
    "log"
7
    "os"
8

9
    "github.com/cloudwego/eino/adk"
10
    "github.com/cloudwego/eino/schema"
11
    "github.com/cloudwego/eino-ext/components/model/openai"
12
)
13

14
func main() {
15
    // 【固定写法】所有 Eino 调用的"通行证"，贯穿整个调用链
16
    ctx := context.Background()
17

18
    // ─── 第1步：创建 ChatModel（"嘴巴"）───
19
    // ChatModel = 与 LLM 通信的组件，屏蔽不同厂商差异
20
    model, err := openai.NewChatModel(ctx, &openai.ChatModelConfig{
21
        APIKey:  os.Getenv("OPENAI_API_KEY"),
22
        Model:   os.Getenv("OPENAI_MODEL"),
23
        BaseURL: os.Getenv("OPENAI_BASE_URL"),
24
    })
25
    if err != nil {
26
        log.Fatal(err)
27
    }
28

29
    // ─── 第2步：创建 Agent（"大脑"）───
30
    agent, err := adk.NewChatModelAgent(ctx, &adk.ChatModelAgentConfig{
31
        Name:        "hello_agent",
32
        Description: "A friendly greeting assistant",
33
        Instruction: "You are a friendly assistant. Please respond warmly.",
34
        Model:       model,   // ← 把第1步的 model 注入进来
35
    })
36
    if err != nil {
37
        log.Fatal(err)
38
    }
39

40
    // ─── 第3步：创建 Runner（"引擎"）───
41
    runner := adk.NewRunner(ctx, adk.RunnerConfig{
42
        Agent:           agent,
43
        EnableStreaming: true,
44
    })
45

46
    // ─── 第4步：组装消息并运行 ───
47
    input := []adk.Message{
48
        schema.UserMessage("Hello, please introduce yourself."),
49
    }
50

51
    // runner.Run() 返回事件迭代器，逐个消费事件
52
    events := runner.Run(ctx, input)
53
    for {
54
        event, ok := events.Next()
55
        if !ok {
56
            break
57
        }
58
        if event.Err != nil {
59
            log.Printf("错误: %v", event.Err)
60
            break
61
        }
62
        if msg, err := event.Output.MessageOutput.GetMessage(); err == nil {
63
            fmt.Printf("Agent: %s\n", msg.Content)
64
        }
65
    }
66
}

💡 关键理解

概念	一句话	类比
`context.Background()`	所有调用的”通行证”，固定写法	身份证，每次办事都要出示
`ChatModel`	负责与 LLM 通信的组件	数据库驱动（屏蔽 MySQL/PG 差异）
`Agent`	封装”怎么用模型”的业务逻辑	业务逻辑层
`Runner`	管理 Agent 的执行生命周期	汽车引擎（你只转方向盘，不管内部）
`events.Next()`	消费下一个事件，没事件了返回 `false`	自助餐流水线，一盘盘拿

🧠 记忆技巧

把创建过程记成一句话：“用某个模型（ChatModel），造一个智能体（Agent），交给引擎（Runner）去跑（Run）”

1
NewChatModel → NewChatModelAgent → NewRunner → Run
2
    (模)            (代)             (跑)       (消息)

常用 import 路径：

1
"github.com/cloudwego/eino-ext/components/model/openai"   // OpenAI 兼容模型，更多代码支持不再列出，直接参考官方文档
2
"github.com/cloudwego/eino/adk"                            // Agent, Runner, Message
3
"github.com/cloudwego/eino/schema"                         // UserMessage, SystemMessage 等

💡 类型别名说明：adk.Message 就是 *schema.Message（Go type alias）。代码里写 []adk.Message{ schema.UserMessage(...) } 和 []*schema.Message{ schema.UserMessage(...) } 是等价的。文档里两种写法都会出现——见到时知道是同一个东西即可。

📇 本节速记卡片

1
NewChatModel → NewChatModelAgent → NewRunner → Run
2
event, ok := iter.Next(); if !ok { break }
3
msg, err := event.Output.MessageOutput.GetMessage()

二、直接用 ChatModel（不用 Agent）

📁 代码：quickstart/chat/main.go、components/prompt/chat_prompt/chat_prompt.go

什么时候不用 Agent？

如果只需要一次性的问答（不涉及多轮对话、工具调用、中断恢复），直接用 ChatModel 更轻量。

两种输出方式

方式	方法	效果	适用场景
一次性	`model.Generate(ctx, messages)`	等全部生成完再返回 `*schema.Message`	批量处理、非实时场景
流式	`model.Stream(ctx, messages)`	返回 `*schema.StreamReader`，逐块接收	聊天、实时显示

示范代码

2.1 用模板构造消息

1
import (
2
    "github.com/cloudwego/eino/components/prompt"
3
    "github.com/cloudwego/eino/schema"
4
)
5

6
// 创建模板：用 {变量名} 做占位符
7
func createTemplate() prompt.ChatTemplate {
8
    return prompt.FromMessages(schema.FString,
9
        schema.SystemMessage("你是一个{role}。用{style}的语气回答。"),
10
        schema.MessagesPlaceholder("chat_history", true),
11
        schema.UserMessage("问题: {question}"),
12
    )
13
}
14

15
// 用模板生成实际消息
16
func createMessages() []*schema.Message { // 正如上面所说，这里使用adk.Message也是一样的
17
    template := createTemplate()
18
    messages, err := template.Format(context.Background(), map[string]any{
19
        "role":     "程序员鼓励师",
20
        "style":    "积极、温暖且专业",
21
        "question": "我的代码一直报错，该怎么办？",
22
        "chat_history": []*schema.Message{
23
            schema.UserMessage("你好"),
24
            schema.AssistantMessage("嘿！加油！", nil),
25
        },
26
    })
27
    // ... 处理 err
28
    return messages
29
}

💡 components/prompt/chat_prompt/chat_prompt.go 展示了一个更完整的模板用法。

2.2 一次性生成（Generate）

1
result, err := model.Generate(ctx, messages)
2
if err != nil {
3
    log.Fatal(err)
4
}
5
fmt.Println(result.Content)

2.3 流式生成（Stream）—— 重点掌握

1
streamReader, err := model.Stream(ctx, messages)
2
if err != nil {
3
    log.Fatal(err)
4
}
5
defer streamReader.Close()  // ⚠️ 用完记得关闭！
6

7
for {
8
    chunk, err := streamReader.Recv()
9
    if err == io.EOF { break }
10
    if err != nil {
11
        log.Fatal(err)
12
    }
13
    fmt.Print(chunk.Content)
14
}

💡 StreamReader 是什么？ model.Stream() 返回的 *schema.StreamReader[*schema.Message] 和 Iterator 类似——模型在后台逐块生成，你通过 Recv() 逐块消费。但有关键区别：

Iterator（Agent 用）：Next() 返回 (event, bool)，!ok 表示 Agent 执行完毕

StreamReader（ChatModel 用）：Recv() 返回 (chunk, error)，io.EOF 表示流结束

defer Close() 是必须的：StreamReader 底层持有 HTTP 连接，不 Close 会导致连接泄漏 / goroutine 泄漏

⚠️ 本节最容易搞混的地方

Eino 里有两种迭代模式，结束判断条件不同：

1
// ─── 模式A：Agent Runner 事件迭代 ───
2
// Next() 返回 (event, bool)，!ok 表示结束
3
for {
4
    event, ok := iter.Next()
5
    if !ok { break }
6
}
7

8
// ─── 模式B：ChatModel Stream 流式迭代 ───
9
// Recv() 返回 (chunk, error)，io.EOF 表示结束
10
defer streamReader.Close()
11
for {
12
    chunk, err := streamReader.Recv()
13
    if err == io.EOF { break }
14
}

记忆诀窍：Agent 用 Next + ok，Stream 用 Recv + EOF。

常用 import 路径（本节新增）：

1
"github.com/cloudwego/eino/components/prompt"   // ChatTemplate, FromMessages

📇 本节速记卡片

1
一次性：model.Generate(ctx, messages) → (*Message, error)
2
流式：  model.Stream(ctx, messages) → (*StreamReader, error)
3
        defer close → Recv() 循环 → io.EOF 结束
4

5
模板：  prompt.FromMessages(schema.FString, ...messages)
6
        template.Format(ctx, map[string]any{...})

三、ChatModelAgent 基础：Tool + Agent + Runner

📁 代码：adk/intro/chatmodel/chatmodel.go

📖 理论：quickstart/chatwitheino/docs/ch02_chatmodel_agent_runner_console

🆕 本节新包速览（先记名字，后面会细讲）：
1
"github.com/cloudwego/eino/components/tool"       // BaseTool, InvokableTool
2
"github.com/cloudwego/eino/components/tool/utils" // InferTool, NewTool
3
"github.com/cloudwego/eino/compose"               // ToolsNodeConfig（Tool 配置容器）
compose 包会在第七节深入讲解——这里你只需要知道 compose.ToolsNodeConfig 是注册 Tool 时用的”配置壳”即可。

3.1 为什么需要 Agent 而不是直接用 ChatModel？

维度	ChatModel（组件）	ChatModelAgent（智能体）
定位	单个能力单元	完整的 AI 应用
输出	`Generate()` / `Stream()` 直接返回消息	`Run()` 返回事件流，可包含工具调用、中断等
多轮对话	需要自己管理 history	Agent 内部处理
工具调用	❌ 不支持	✅ 通过 ToolsConfig 配置
中断恢复	❌ 不支持	✅ 通过 CheckPointStore
适用场景	简单的一次性问答	复杂智能体应用

3.2 创建 Tool 的三种方式

📁 补充代码：quickstart/todoagent/main.go

Eino 提供三种创建 Tool 的方式：

方式	做法	适合场景
方式一：InferTool	写一个普通函数，自动从 struct tag 推断 schema	最常用，90% 场景
方式二：NewTool	手动写 `schema.ToolInfo`，传给 `utils.NewTool`	需要精确控制参数约束
方式三：结构体实现接口	struct 实现 `Info()` + `InvokableRun()`	Tool 逻辑复杂，需要带状态

方式一：InferTool（自动推断，最常用）⭐

1
import (
2
    "github.com/cloudwego/eino/components/tool"
3
    "github.com/cloudwego/eino/components/tool/utils"
4
)
5

6
// ① 定义输入结构体（用 json tag + jsonschema tag 描述参数）
7
type BookSearchInput struct {
8
    Genre    string `json:"genre" jsonschema_description:"书籍类型"`
9
    MaxPages int    `json:"max_pages" jsonschema_description:"最大页数"`
10
}
11

12
type BookSearchOutput struct {
13
    Books []string `json:"books"`
14
}
15

16
// ② 写业务函数 + utils.InferTool 自动包装
17
func NewBookSearchTool() tool.InvokableTool {
18
    t, _ := utils.InferTool(
19
        "search_book",
20
        "Search books by preferences",
21
        func(ctx context.Context, input *BookSearchInput) (*BookSearchOutput, error) {
22
            return &BookSearchOutput{Books: []string{"《三体》"}}, nil
23
        },
24
    )
25
    return t
26
}

方式二：NewTool（手动定义 schema）

当需要更精确控制参数描述、添加枚举约束等场景时使用：

1
func getAddTodoTool() tool.InvokableTool {
2
    info := &schema.ToolInfo{
3
        Name: "add_todo",
4
        Desc: "Add a todo item",
5
        ParamsOneOf: schema.NewParamsOneOfByParams(map[string]*schema.ParameterInfo{
6
            "content": {
7
                Desc:     "The content of the todo item",
8
                Type:     schema.String,
9
                Required: true,
10
            },
11
            "deadline": {
12
                Desc: "The deadline of the todo item, in unix timestamp",
13
                Type: schema.Integer,
14
            },
15
        }),
16
    }
17
    return utils.NewTool(info, AddTodoFunc)
18
}
19

20
type TodoAddParams struct {
21
    Content  string `json:"content"`
22
    Deadline *int64 `json:"deadline,omitempty"`
23
}
24

25
func AddTodoFunc(_ context.Context, params *TodoAddParams) (string, error) {
26
    return `{"msg": "add todo success"}`, nil
27
}

方式三：结构体实现接口（最灵活）

Tool 需要带状态、或者逻辑很复杂时，直接实现接口：

1
type ListTodoTool struct{}
2

3
func (lt *ListTodoTool) Info(_ context.Context) (*schema.ToolInfo, error) {
4
    return &schema.ToolInfo{
5
        Name: "list_todo",
6
        Desc: "List all todo items",
7
        ParamsOneOf: schema.NewParamsOneOfByParams(map[string]*schema.ParameterInfo{
8
            "finished": {
9
                Desc: "filter todo items if finished",
10
                Type: schema.Boolean,
11
            },
12
        }),
13
    }, nil
14
}
15

16
func (lt *ListTodoTool) InvokableRun(_ context.Context, argumentsInJSON string, _ ...tool.Option) (string, error) {
17
    return `{"todos": [...]}`, nil
18
}

🧠 怎么选：90% 场景用 InferTool 就够了；需要手动约束参数类型/枚举值时用 NewTool；Tool 本身带状态（比如有数据库连接）时用结构体方式。三种方式注册到 Agent 的方式完全一样——都丢进 ToolsConfig.Tools 数组里。

3.3 组装完整应用（Tool + 流式）

ℹ️ 本节聚焦：只展示 Tool + Agent + Runner + Query 的主流程。中断恢复（Resume）会单独在第五节讲。

1
package main
2

3
import (
4
    "context"
5
    "fmt"
6
    "log"
7
    "os"
8

9
    "github.com/cloudwego/eino/adk"
10
    "github.com/cloudwego/eino/components/tool"
11
    "github.com/cloudwego/eino/compose"
12
    "github.com/cloudwego/eino/schema"
13
    "github.com/cloudwego/eino-ext/components/model/openai"
14
)
15

16
func main() {
17
    ctx := context.Background()
18

19
    // ─── 创建模型 ───
20
    model, err := openai.NewChatModel(ctx, &openai.ChatModelConfig{
21
        APIKey:  os.Getenv("OPENAI_API_KEY"),
22
        Model:   os.Getenv("OPENAI_MODEL"),
23
        BaseURL: os.Getenv("OPENAI_BASE_URL"),
24
    })
25
    if err != nil {
26
        log.Fatal(err)
27
    }
28

29
    // ─── 创建 Agent（配置 Tool）───
30
    agent, err := adk.NewChatModelAgent(ctx, &adk.ChatModelAgentConfig{
31
        Name:        "BookRecommender",
32
        Description: "An agent that recommends books",
33
        Instruction: "You are a book expert. Use search_book tool to find books.",
34
        Model:       model,
35
        ToolsConfig: adk.ToolsConfig{
36
            ToolsNodeConfig: compose.ToolsNodeConfig{
37
                Tools: []tool.BaseTool{
38
                    NewBookSearchTool(),
39
                },
40
            },
41
        },
42
    })
43
    if err != nil {
44
        log.Fatal(err)
45
    }
46

47
    // ─── 创建 Runner（配置流式）───
48
    runner := adk.NewRunner(ctx, adk.RunnerConfig{
49
        Agent:           agent,
50
        EnableStreaming: true,
51
    })
52

53
    // ─── 运行 ───
54
    iter := runner.Query(ctx, "推荐一本科幻小说")
55
    for {
56
        event, ok := iter.Next()
57
        if !ok { break }
58
        if event.Err != nil {
59
            log.Fatal(event.Err)
60
        }
61
        fmt.Printf("Event: %+v\n", event)
62
    }
63
}

3.4 配置项归属速查

记住一句话：Agent 管”有什么能力”，Runner 管”怎么执行”。

配置	在哪里设置	作用
`Instruction`	`ChatModelAgentConfig`	系统提示词，定义 Agent 的”人设”
`ToolsConfig`	`ChatModelAgentConfig`	注册 Agent 可用的工具
`EnableStreaming: true`	`RunnerConfig`	流式输出（打字机效果）
`CheckPointStore`	`RunnerConfig`	保存执行状态，支持中断恢复（第五节）

3.5 底层视角：Agent 的本质是一个接口

📁 代码：adk/intro/custom/myagent.go

adk.NewChatModelAgent 内部实现了 adk.Agent 接口：

1
type Agent interface {
2
    Name(ctx) string
3
    Description(ctx) string
4
    Run(ctx, input, ...options) *AsyncIterator[*AgentEvent]
5
}

myagent.go 展示了最简实现——三个关键点：

NewAsyncIteratorPair = 建一条事件流水线，gen 管发送，iter 管接收
开 goroutine 是因为 Run() 要立即返回 iter，事件在后台异步生成
gen.Close() 必须调用，否则消费端的 Next() 会永远阻塞

常用 import 路径（本节新增）：

1
"github.com/cloudwego/eino/components/tool"       // BaseTool, InvokableTool, Option
2
"github.com/cloudwego/eino/components/tool/utils" // InferTool, NewTool
3
"github.com/cloudwego/eino/compose"               // ToolsNodeConfig

📇 本节速记卡片

1
Agent.{Name, Instruction, ToolsConfig, Model}
2
Runner.{Agent, EnableStreaming, CheckPointStore}
3

4
Tool 三种创建：InferTool（90%）/ NewTool / 结构体接口
5
注册方式都一样：ToolsConfig.Tools = []tool.BaseTool{ toolfuction...}
6

7
附注：如果忘记某特定的struct需要填写什么可以直接看源码接口定义

四、Middleware：给 Agent 加拦截器

📁 代码：

quickstart/chatwitheino/helpers/middleware.go - SafeToolMiddleware，自定义一个新的middleware

quickstart/chatwitheino/helpers/retry.go - 错误自动重试

adk/middlewares/dynamictool/toolsearch/ — 动态工具检索中间件

adk/middlewares/skill/main.go — 技能加载中间件

📖 理论：quickstart/chatwitheino/docs/ch05_middleware

4.1 为什么需要 Middleware？

两个常见问题：

问题一：Tool 报错导致整个对话崩溃

1
[tool call] read_file(file_path: "nonexistent.txt")
2
Error: open nonexistent.txt: no such file or directory
3
// 💥 对话直接中断

问题二：模型 API 限流导致失败

1
Error: rate limit exceeded (429)
2
// 💥 对话中断

你希望的行为是：Tool 报错时把错误交给 LLM 自愈；模型限流时自动重试。这就是 Middleware 要解决的问题——Agent 的拦截器，在调用前后插入自定义逻辑。

4.2 Middleware 的本质：洋葱模型

1
请求 → A.Wrap → B.Wrap → C.Wrap → 实际执行 → C返回 → B返回 → A返回 → 响应
2
         ↑                          ↑
3
    最外层先拦截                 最内层先接触实际执行结果

4.3 核心场景一：SafeToolMiddleware（自定义一个新的middleware：Tool 错误转字符串）

1
// 定义一个结构体来承载中间件的逻辑。内嵌一个基础中间件（Base Middleware），以复用其默认行为。
2
type safeToolMiddleware struct {
3
    *adk.BaseChatModelAgentMiddleware
4
}
5

6
// 拦截同步工具调用，BaseChatModelAgentMiddleware中定义了方法的签名
7
func (m *safeToolMiddleware) WrapInvokableToolCall(
8
    _ context.Context,
9
    endpoint adk.InvokableToolCallEndpoint,
10
    _ *adk.ToolContext,
11
) (adk.InvokableToolCallEndpoint, error) {
12
    return func(ctx context.Context, args string, opts ...tool.Option) (string, error) {
13
        // 拦截原始 endpoint的结果和err
14
        result, err := endpoint(ctx, args, opts...)
15
        if err != nil {
16
            // ⚠️ 中断错误必须继续传播，不能吞掉
17
            if _, ok := compose.IsInterruptRerunError(err); ok {
18
                return "", err
19
            }
20
            // 普通错误 → 转成字符串，让 LLM 看到
21
            return fmt.Sprintf("[tool error] %v", err), nil
22
        }
23
        // 没有错误就直接返回原始的结果
24
        return result, nil
25
    }, nil
26
}
27

28
// 还可以拦截其他的调用如WrapStreamableToolCall 拦截流式工具调用等等，可以自行查看官方示例

💡 关键区分：compose.IsInterruptRerunError 是中断恢复（第五节）抛出的特殊错误，它必须继续向上传播，不能转成字符串。

4.4 核心场景二：ModelRetryConfig（模型调用自动重试）

原来的IsRetryAble被标记弃用，现在应该使用ShouldRetry进行替代

部分中间件可以直接在agent定义时注明，如ModelRetryConfig

1
ModelRetryConfig: &adk.ModelRetryConfig{
2
    MaxRetries: 5,
3
    ShouldRetry: func(ctx context.Context, retryCtx *adk.TypedRetryContext[M]) *adk.TypedRetryDecision[M] {
4
        // 获取错误信息
5
        err := retryCtx.Error
6
        // 判断是否需要重试
7
        if err != nil && (strings.Contains(err.Error(), "429") || strings.Contains(err.Error(), "Too Many Requests")) {
8
            // 返回重试决策
9
            return &adk.TypedRetryDecision[M]{
10
                Retry: true,
11
                // 在这里你还可以修改重试时的输入或选项，等等
12
            }
13
        }
14
        // 不需要重试，返回 nil 或 Retry: false
15
        return nil
16
    },
17
},

4.5 核心场景三：动态工具检索（ToolSearch Middleware）

eino还预先定义了部分middleware，如agentsmd、dynamictool/toolsearch等，可以直接调用，下面介绍一些常见的

📁 adk/middlewares/dynamictool/toolsearch/

痛点：Tool 太多会撑爆上下文窗口。ToolSearch 先把所有 Tool 放进”工具库”，调用时搜索过滤：

1
toolSearchMiddleware, _ := toolsearch.New(ctx, &toolsearch.Config{
2
    DynamicTools: allDynamicTools,
3
})
4

5
agent, _ := adk.NewChatModelAgent(ctx, &adk.ChatModelAgentConfig{
6
    Name:  "tool_search_agent",
7
    Model: chatModel,
8
    Handlers: []adk.ChatModelAgentMiddleware{
9
        toolSearchMiddleware,  // ← 不是 ToolsConfig！
10
    },
11
})

🧠 与第三节 ToolsConfig 的区别：第三节把 Tool 写在 ToolsConfig.Tools 里——全部发给 LLM。ToolSearch 先用搜索过滤，只把相关的发给 LLM。

4.6 核心场景四：Skill Middleware（动态加载技能）

📁 adk/middlewares/skill/main.go

创建 Skill 后端

1
skillBackend, err := skill.NewBackendFromFilesystem(ctx, &skill.BackendFromFilesystemConfig{
2
    Backend: be,
3
    BaseDir: skillsDir, // 指定扫描的根目录
4
})

创建并注入 Skill 中间件

1
sm, err := skill.NewMiddleware(ctx, &skill.Config{
2
    Backend: skillBackend,
3
})

之后在运行时从文件系统动态加载”技能”（预定义的提示词+工具组合）

1
// 文件系统中间件 → Skill 中间件（有序！）
2
agent, _ := adk.NewChatModelAgent(ctx, &adk.ChatModelAgentConfig{
3
    Name:  "LogAnalysisAgent",
4
    Model: cm,
5
    Handlers: []adk.ChatModelAgentMiddleware{
6
        fsm,  // 文件读写能力（洋葱模型外层，最先wrap，最后返回）
7
        sm,   // Skill 加载能力（洋葱模型内层，之后wrap，先返回）
8
    },
9
})

4.7 Middleware 全景速查

Middleware 类型	解决什么痛点	来源	配置位置
SafeToolMiddleware	Tool 报错中断对话 → 转成字符串让 LLM 自愈	自己实现	`Handlers`
ModelRetryConfig	模型 API 限流 → 自动重试	`adk.ModelRetryConfig`（内置）	`ChatModelAgentConfig`
ToolSearch	Tool 太多撑爆上下文 → 动态检索注入	`toolsearch.New()`	`Handlers`
Skill	运行时动态加载技能 → 从文件系统读	`skill.NewMiddleware()`	`Handlers`
filesystem	Agent 需要读写文件系统	`filesystem.New()`	`Handlers`

🧠 模型：安检通道

1
用户请求 → [安检A:查证件] → [安检B:过X光] → [安检C:金属探测] → 登机
2
用户收到 ← [安检A:盖章]   ← [安检B:贴标签] ← [安检C:称重]   ← 行李出来

📇 本节速记卡片

1
SafeToolMiddleware = 错误转字符串（除了 InterruptRerunError）
2
ModelRetryConfig   = 限流自动重试（内置配置项）
3
ToolSearch         = 工具池动态搜索（替代 ToolsConfig）
4
Skill              = 文件系统加载技能
5

6
通用模式：嵌入 BaseChatModelAgentMiddleware → 覆写一个钩子 → 放入 Handlers

五、中断与恢复（Interrupt & Resume）

📁 代码：

adk/intro/chatmodel/ — Tool 中断

adk/cancel/graceful-exit/ — 外部取消

adk/human-in-the-loop/ — 人机协作全套示例

📖 Memory 理论：quickstart/chatwitheino/docs/ch03_memory_session_jsonl

📖 Tool 理论：quickstart/chatwitheino/docs/ch04_tool_backend_filesystem

5.1 中断机制总览

这是 Eino ADK 的核心高级特性。整个机制基于一个简单的状态机：

stateDiagram-v2
    [*] --> Running: runner.Query/Run(checkpointID)
    Running --> Interrupted: compose.Interrupt()
    Running --> Cancelled: Ctrl-C → cancelFn()
    Running --> Completed: 正常结束
    Running --> HITL_Interrupted: compose.Interrupt()

    Interrupted --> Resuming: runner.Resume(checkpointID, WithToolOptions)
    Cancelled --> ResumingNew: 新runner.Resume(checkpointID)
    HITL_Interrupted --> ResumingHITL: runner.ResumeWithParams(checkpointID, params)

    Resuming --> Running
    ResumingNew --> Running
    ResumingHITL --> Running
    Completed --> [*]

三种触发方式对比如下：

	方式一：Tool 中断（本质就是方式三）	方式二：外部取消	方式三：Human-in-the-Loop
触发源	Tool 调用 `compose.Interrupt“	系统信号 Ctrl-C	Tool 调用 `compose.Interrupt`
Runner	同一个 runner	新建 runner	同一个 runner
Resume API	`runner.Resume` + `WithToolOptions`	新 `runner.Resume`	`runner.ResumeWithParams`
典型场景	信息不足，等用户补充	长时间运行，用户想中止	敏感操作审批、参数审核

共同点：都依赖 CheckPointStore + CheckPointID。

🆕 本节新包速览：

1
"github.com/cloudwego/eino/compose"  // CheckPointStore（中断状态存储接口）
2
// CheckPointStore 有多种实现，如：
3
//   store.NewInMemoryStore()  ← 内存实现（开发用）
4
// 第五节只关注中断API，CheckPointStore 的底层原理见第七节

5.2 方式一：Tool 内部中断（主动暂停等输入）

1
用户输入 "推荐一本书"
2
       │
3
       ▼
4
    runner := adk.NewRunner(ctx, adk.RunnerConfig{
5
    Agent:           a,
6
    CheckPointStore: store.NewInMemoryStore(), // runner设置CheckPointStore以储存后续的CheckPointID
7
  })
8
       │
9
       ▼
10
  runner.Query(ctx, "推荐一本书", WithCheckPointID("1")) 传入CheckPointID，后续恢复通过这个
11
       │
12
       ▼
13
  Agent 分析：信息不够 → Tool 返回 Interrupt("请问你喜欢什么类型的书？") 注：示例代码中NewInterruptAndRerunErr被标记启用
14
       │
15
       ▼
16
  事件流中收到 Interrupted 事件 → 暂停，等待用户输入
17
       │
18
       ▼
19
  runner.Resume(ctx, "1", WithToolOptions(WithNewInput("科幻"))) 通过CheckPointID进行恢复
20
       │
21
       ▼
22
  Agent 继续执行 → 用 "科幻" 重新调用 Tool → 返回结果

注：既然这个已经过时+本质和方法三相同，可以直接看方法三是如何中断的

5.3 方式二：外部取消（Ctrl-C 优雅退出）

📁 adk/cancel/graceful-exit/main.go

设计意图：用户按 Ctrl-C 时不直接杀进程白跑——而是安全暂停、自动保存进度、之后从断点恢复。

1
用户按 Ctrl-C
2
       │
3
       ▼
4
  cancelFn(CancelAfterChatModel, WithRecursive, 30s超时)
5
       │
6
       ├─→ CancelAfterChatModel: 等当前 ChatModel 调用完成再停
7
       ├─→ WithRecursive: 递归传播到子 Agent
8
       └─→ 超时兜底: 30s 内没到安全点 → 强制 CancelImmediate
9
       │
10
       ▼
11
  CheckPointStore 自动保存状态 → 新 Runner.Resume 恢复

取消的创建

1
// 创建取消选项与外部触发函数
2
cancelOpt, cancelFn := adk.WithCancel()
3

4
// 启动Agent运行，绑定断点ID
5
iter := runner.Run(ctx, input, cancelOpt, adk.WithCheckPointID(checkpointID))
6

7
// 注册系统信号监听：SIGINT(Ctrl-C)、SIGTERM
8
sigCh := make(chan os.Signal, 1)
9
signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
10

11
go func() {
12
  sig := <-sigCh
13
  fmt.Printf("\n收到操作系统信号: %v，发起Agent优雅取消\n", sig)
14

15
  // 发起优雅取消：等待ChatModel安全点、递归传播子Agent、30s超时兜底
16
  handle, contributed := cancelFn(
17
    adk.WithAgentCancelMode(adk.CancelAfterChatModel),
18
    adk.WithRecursive(),
19
    adk.WithAgentCancelTimeout(30*time.Second),
20
  )
21
  fmt.Printf("取消请求是否成功提交: %v\n", contributed)
22

23
  // 阻塞等待取消流程完成（断点持久化完成后返回）
24
  if waitErr := handle.Wait(); waitErr != nil {
25
    fmt.Printf("优雅取消异常: %v\n", waitErr)
26
  } else {
27
    fmt.Println("优雅取消完成，断点已保存")
28
  }
29
}()

取消的恢复

1
// 使用同一个CheckPointStore，新建Runner恢复
2
resumeRunner := adk.NewRunner(ctx, adk.RunnerConfig{
3
  Agent:           agent,
4
  EnableStreaming: true,
5
  CheckPointStore: cpStore,
6
})
7
resumeIter, err := resumeRunner.Resume(ctx, checkpointID)
8
if err != nil {
9
  log.Fatalf("断点恢复失败: %v", err)
10
}
11
drainEvents(resumeIter)

5.4 方式三：Human-in-the-Loop 人机协作（ResumeWithParams）

📁 adk/human-in-the-loop/1_approval/ ~ 8_supervisor-plan-execute/

通过 interruptID 精确匹配中断点，注入任意类型的数据：

1
// ① 启动
2
iter := runner.Query(ctx, query, adk.WithCheckPointID("1"))
3

4
// ② 检测中断，提取 interruptID
5
interruptCtx := lastEvent.Action.Interrupted.InterruptContexts[0]
6
interruptID := interruptCtx.ID
7

8
// ③ 用户决策后，通过 ResumeWithParams 传回
9
iter, _ = runner.ResumeWithParams(ctx, "1", &adk.ResumeParams{
10
    Targets: map[string]any{
11
        interruptID: modifiedInfo,
12
    },
13
})

中断方：

1
func FollowUp(ctx context.Context, input *FollowUpToolInput) (string, error) {
2
    // 首次进入（触发中断）
3
  wasInterrupted, _, storedState := tool.GetInterruptState[*FollowUpState](ctx)
4
  if !wasInterrupted {
5
        // 准备要展示给用户的信息（比如问题列表）
6
        info := &FollowUpInfo{Questions: input.Questions}
7
        // 准备要保存的状态（为了恢复时知道我们在干嘛）
8
        state := &FollowUpState{Questions: input.Questions}
9

10
        // 触发中断！把 info 发给前端展示，把 state 存起来，然后函数立刻返回
11
        return "", tool.StatefulInterrupt(ctx, info, state)
12
    }
13

14
    // 第二次进入
15
  isResumeTarget, hasData, resumeData := tool.GetResumeContext[*FollowUpInfo](ctx)
16
  if !isResumeTarget {
17
      // 如果系统唤醒了这个函数，但发现它不是当前该恢复的目标
18
        // 那就把之前保存的状态再拿出来，继续中断等待
19
    info := &FollowUpInfo{Questions: storedState.Questions}
20
    return "", tool.StatefulInterrupt(ctx, info, storedState)
21
  }
22
    // 被唤醒，但还没拿到答案（防御性重入）
23
  if !hasData || resumeData.UserAnswer == "" {
24
    return "", fmt.Errorf("tool resumed without a user answer")
25
  }
26

27
    // 成功恢复，拿到答案（正常退出）
28
  return resumeData.UserAnswer, nil
29
}

四种交互模式（区别仅在于 info 类型和用户操作）：

模式	中断时携带的信息	用户操作	示例目录
审批	`ApprovalResult`	Y/N 批准或拒绝	`1_approval`, `5_supervisor`
审核编辑	`ReviewEditInfo`	修改参数 / 批准 / 拒绝	`2_review-and-edit`
反馈循环	`FeedbackInfo`	输入反馈意见	`3_feedback-loop`
追问	`FollowUpInfo`	逐个回答问题	`4_follow-up`, `7_deep-agents`

💡 ResumeWithParams vs 旧 Resume：ResumeWithParams 是通用 API，Resume + WithToolOptions 是其特例。

📇 本节速记卡片

1
中断恢复三要素：CheckPointStore（存状态）+ CheckPointID（标识）+ Resume（恢复）
2

3
方式一：compose.Interrupt → runner.Resume(id, WithToolOptions)
4
方式二：Ctrl-C → cancelFn → 新 runner.Resume(id)
5
方式三：compose.Interrupt → runner.ResumeWithParams(id, {Targets: {interruptID: data}})

六、进阶主题

6.1 Callbacks 与 Tracing（可观测性）

📁 adk/common/trace/coze_loop.go

1
traceCloseFn, startSpanFn := trace.AppendCozeLoopCallbackIfConfigured(ctx)
2
defer traceCloseFn(ctx)
3

4
ctx, endSpanFn := startSpanFn(ctx, "MyTask", "user query")
5
// ... runner.Query(ctx, query) ...
6
endSpanFn(ctx, lastMessage)

6.2 Workflow Agent：编排多个 Agent 的协作方式

📁 adk/intro/workflow/loop/, parallel/, sequential/

三种内置工作流 Agent：

类型	模式	适用场景
LoopAgent	主Agent生成 → 评审审查 → 不满意重改	需要反复打磨的任务
ParallelAgent	多个子Agent同时接收相同输入，各自执行	同时从多数据源收集信息
SequentialAgent	子Agent逐个执行，前一个输出→后一个输入	分步任务流水线

1
// LoopAgent
2
a, _ := adk.NewLoopAgent(ctx, &adk.LoopAgentConfig{
3
    SubAgents:     []adk.Agent{mainAgent, critiqueAgent},
4
    MaxIterations: 5,
5
})
6

7
// ParallelAgent
8
a, _ := adk.NewParallelAgent(ctx, &adk.ParallelAgentConfig{
9
    SubAgents: []adk.Agent{stockAgent, newsAgent, socialAgent},
10
})
11

12
// SequentialAgent
13
a, _ := adk.NewSequentialAgent(ctx, &adk.SequentialAgentConfig{
14
    SubAgents: []adk.Agent{planAgent, writerAgent},
15
})

6.3 Multi-Agent：Supervisor 模式

📁 adk/multiagent/supervisor/, layered-supervisor/, plan-execute-replan/

Supervisor：一个”主管”Agent 分析用户请求，决定派给哪个”专家”子 Agent。

1
sv, _ := adk.NewChatModelAgent(ctx, &adk.ChatModelAgentConfig{
2
    Name: "supervisor",
3
    Instruction: "You are a supervisor managing a research_agent and math_agent.",
4
    Model: m,
5
})
6

7
supervisorAgent, _ := supervisor.New(ctx, &supervisor.Config{
8
    Supervisor: sv,
9
    SubAgents:  []adk.Agent{searchAgent, mathAgent},
10
})

Layered Supervisor：子 Agent 本身也可以是 Supervisor，形成树状调度。

Plan-Execute-Replan：Planner 制定计划 → Executor 逐步执行 → Replanner 检查并修改计划。

1
entryAgent, _ := planexecute.New(ctx, &planexecute.Config{
2
    Planner:    planAgent,
3
    Executor:   executeAgent,
4
    Replanner:  replanAgent,
5
    MaxIterations: 20,
6
})

🧠 三种多 Agent 模式对比：

Workflow Agent（6.2）：编排是固定的（顺序/并行/循环）

Supervisor（6.3）：编排是动态的，由 LLM 决定派给谁

Plan-Execute-Replan：适合需要多步规划且计划可能中途调整的复杂任务

6.4 Compose 编排 API 总览

按抽象层级从高到低：

1
ADK (Agent+Runner)  >  Chain  >  Graph  >  Workflow
2
  高层，开箱即用                    底层，精细控制每个节点和数据流

API	特点	适合场景
Workflow	字段映射 + 自动依赖推导	纯函数数据流水线
Graph	手动 AddEdge 建图，支持 State	LLM 调用流程、有状态分支
Chain	链式 Append 节点	ChatModel → ToolsNode 线性流程
Batch	批量并行处理 N 个输入	文档批量审核等

Graph 基础用法

1
g := compose.NewGraph[map[string]any, *schema.Message]()
2
_ = g.AddChatTemplateNode("prompt", pt)
3
_ = g.AddChatModelNode("model", chatModel)
4
_ = g.AddEdge(compose.START, "prompt")
5
_ = g.AddEdge("prompt", "model")
6
_ = g.AddEdge("model", compose.END)
7
runner, _ := g.Compile(ctx)
8
result, _ := runner.Invoke(ctx, input)

Chain 基础用法

1
chain := compose.NewChain[map[string]any, string]()
2
chain.
3
    AppendLambda(preprocess).
4
    AppendBranch(compose.NewChainBranch(cond).AddLambda("b1", fn1).AddLambda("b2", fn2)).
5
    AppendLambda(postprocess)
6
runner, _ := chain.Compile(ctx)

📇 本节速记卡片

1
Workflow Agent: LoopAgent / ParallelAgent / SequentialAgent
2
Supervisor:      supervisor.New({Supervisor, SubAgents})
3
Compose 编排:   Graph(AddEdge) / Chain(Append) / Workflow(MapFields)

七、完整架构分层图

graph TD
    Q["你要做什么？"] --> Q1{"简单一次性问答？"}
    Q1 -->|是| CM["ChatModel.Generate/Stream
§2"]
    Q1 -->|否| Q2{"标准 Agent
问答+工具+记忆？"}
    Q2 -->|是| ADK["ChatModelAgent + Runner
§3"]
    Q2 -->|否| Q3{"自定义 ReAct 循环？"}
    Q3 -->|是| REACT["react.NewAgent
appendix1 §1"]
    Q3 -->|否| Q4{"多 Agent 协作？"}
    Q4 -->|调度模式| SUP["ADK Supervisor
§6.3
或 Host MultiAgent
appendix1 §6"]
    Q4 -->|流水线| PE["Plan-Execute
appendix1 §7"]
    Q4 -->|复杂状态图| CUSTOM["自定义 Graph+State
appendix1 §9"]
    Q4 -->|否| Q5{"精细控制每个节点？"}
    Q5 -->|是| GRAPH["Compose Graph/Chain
§6.4"]
    Q5 -->|否| CHECK["回到 ADK 路径"]

📇 全篇速记卡片（完整版）

1
┌─ 创建链 ─────────────────────────────────────────────┐
2
│ NewChatModel → NewChatModelAgent → NewRunner → Run   │
3
│   (模)            (代)             (跑)       (消息)  │
4
├─ 两种迭代 ───────────────────────────────────────────┤
5
│ Agent: for { event, ok := iter.Next(); if !ok {break}}│
6
│ Stream: for { chunk, err := sr.Recv(); io.EOF → break}│
7
├─ 职责分离 ───────────────────────────────────────────┤
8
│ Agent 管能力:{Name, Instruction, ToolsConfig, Model} │
9
│ Runner管执行:{Agent, EnableStreaming, CheckPointStore}│
10
├─ Tool 创建 ──────────────────────────────────────────┤
11
│ InferTool（90%）/ NewTool / 结构体接口               │
12
├─ Middleware  ────────────────────────────────────────┤
13
│ SafeTool / ModelRetry / ToolSearch / Skill           │
14
├─ 中断恢复 ──────────────────────────────────────────┤
15
│ CheckPointStore + CheckPointID + Resume              │
16
│ 三种方式：Tool中断 / Ctrl-C取消 / Human-in-the-Loop  │
17
├─ 编排层次 ──────────────────────────────────────────┤
18
│ ADK(Agent+Runner) > Chain > Graph > Workflow        │
19
├─ Agentic 路径（[Agentic 进阶](./agentic)）──────────────────────────┤
20
│ 所有类型加 Typed[*AgenticMessage] 即可               │
21
└──────────────────────────────────────────────────────┘

常用 import 路径（全篇汇总）：

1
// 模型
2
"github.com/cloudwego/eino-ext/components/model/openai"    // OpenAI 兼容 ChatModel
3

4
// ADK 核心
5
"github.com/cloudwego/eino/adk"                             // Agent, Runner, Message, Middleware
6
"github.com/cloudwego/eino/schema"                          // UserMessage, SystemMessage, ToolInfo
7

8
// Tool
9
"github.com/cloudwego/eino/components/tool"                 // BaseTool, InvokableTool
10
"github.com/cloudwego/eino/components/tool/utils"           // InferTool, NewTool
11

12
// 编排
13
"github.com/cloudwego/eino/compose"                         // Graph, Chain, Workflow, ToolsNodeConfig
14

15
// Middleware 扩展
16
"github.com/cloudwego/eino/adk/middlewares/dynamictool/toolsearch"  // ToolSearch
17
"github.com/cloudwego/eino/adk/middlewares/skill"                   // Skill
18
"github.com/cloudwego/eino/adk/middlewares/filesystem"              // 文件系统
19

20
// Prompt
21
"github.com/cloudwego/eino/components/prompt"               // ChatTemplate, FromMessages

⚠️ 常见坑（Common Gotchas）

开发 Eino 应用时，下面几个坑最容易踩到——每个都用一个”坏代码 vs 好代码”的对比来展示：

坑 1：忘记 `defer streamReader.Close()` → goroutine 泄漏

1
// ❌ 坏：忘记 Close，HTTP 连接永不释放，goroutine 泄漏
2
sr, _ := model.Stream(ctx, messages)
3
for { chunk, err := sr.Recv(); ... }
4

5
// ✅ 好：defer Close 保证无论怎么退出都会关闭
6
sr, _ := model.Stream(ctx, messages)
7
defer sr.Close()
8
for { chunk, err := sr.Recv(); ... }

坑 2：自定义 Agent 忘记 `gen.Close()` → `Next()` 永远阻塞

1
// ❌ 坏：忘记 Close，消费端 Next() 永远等不到 false
2
func (m *MyAgent) Run(...) *AsyncIterator[*AgentEvent] {
3
    iter, gen := adk.NewAsyncIteratorPair[*AgentEvent]()
4
    go func() {
5
        gen.Send(&AgentEvent{...})
6
        // 忘记 gen.Close()！！！
7
    }()
8
    return iter
9
}
10

11
// ✅ 好：defer + recover 确保 Close 一定被调用
12
func (m *MyAgent) Run(...) *AsyncIterator[*AgentEvent] {
13
    iter, gen := adk.NewAsyncIteratorPair[*AgentEvent]()
14
    go func() {
15
        defer func() {
16
            if e := recover() { gen.Send(&AgentEvent{Err: ...}) }
17
            gen.Close()  // ← 必须调用！
18
        }()
19
        gen.Send(&AgentEvent{...})
20
    }()
21
    return iter
22
}

坑 3：SafeToolMiddleware 误吞中断错误

1
// ❌ 坏：所有 error 都转成字符串，中断错误也被吞了
2
func wrap(endpoint) endpoint {
3
    return func(ctx, args) (string, error) {
4
        result, err := endpoint(ctx, args)
5
        if err != nil { return fmt.Sprintf("[error] %v", err), nil }
6
        return result, nil
7
    }
8
}
9

10
// ✅ 好：区分中断错误和普通错误
11
func wrap(endpoint) endpoint {
12
    return func(ctx, args) (string, error) {
13
        result, err := endpoint(ctx, args)
14
        if err != nil {
15
            if _, ok := compose.IsInterruptRerunError(err); ok {
16
                return "", err  // ← 中断错误必须传播！
17
            }
18
            return fmt.Sprintf("[tool error] %v", err), nil
19
        }
20
        return result, nil
21
    }
22
}

坑 4：Resume 时 CheckPointID 不一致

1
// ❌ 坏：Query 和 Resume 用了不同的 ID——Runner 找不到之前的保存点
2
iter := runner.Query(ctx, "帮我推荐", adk.WithCheckPointID("session-1"))
3
// ... 中断 ...
4
iter, _ = runner.Resume(ctx, "session-2")  // ← ID 不一致！应该是 "session-1"
5

6
// ✅ 好：同一个 ID
7
iter := runner.Query(ctx, "帮我推荐", adk.WithCheckPointID("session-1"))
8
// ... 中断 ...
9
iter, _ = runner.Resume(ctx, "session-1")  // ← 一致！

坑 5：Resume 时用了新的 Runner 但没传同一个 CheckPointStore

1
// ❌ 坏：新 Runner 没用同一个 CheckPointStore——状态丢失
2
runner1 := adk.NewRunner(ctx, adk.RunnerConfig{Agent: agent})  // 默认空 Store
3
iter := runner1.Query(ctx, "query", adk.WithCheckPointID("1"))
4
// ... Ctrl-C 取消 ...
5
runner2 := adk.NewRunner(ctx, adk.RunnerConfig{Agent: agent})  // 另一个空 Store
6
iter, _ = runner2.Resume(ctx, "1")  // ← 找不到 checkpoint！
7

8
// ✅ 好：共享同一个 CheckPointStore
9
store := store.NewInMemoryStore()
10
runner1 := adk.NewRunner(ctx, adk.RunnerConfig{Agent: agent, CheckPointStore: store})
11
runner1.Query(...)
12
// ...
13
runner2 := adk.NewRunner(ctx, adk.RunnerConfig{Agent: agent, CheckPointStore: store})
14
runner2.Resume(ctx, "1")  // ← 找得到！

坑 6：服务端工具（web_search）期待 function_tool_result

1
// ❌ 坏：等不到 web_search 的 function_tool_result
2
for _, block := range msg.ContentBlocks {
3
    if block.Type == schema.ContentBlockTypeFunctionToolResult {
4
        // web_search 永远不会产生这个！
5
    }
6
}
7

8
// ✅ 好：理解 server_tool_call 在厂商侧执行，没有对应的 function_tool_result
9
for _, block := range msg.ContentBlocks {
10
    if block.Type == schema.ContentBlockTypeServerToolCall {
11
        // 模型已经消费了搜索结果——你只会看到后续的 reasoning/text block
12
        fmt.Println("服务端搜索完成:", block.ServerToolCall.Name)
13
    }
14
}

🧠 总结：上面六个坑覆盖了 90% 的 Eino 开发问题。记住三条原则：

打开要关（StreamReader → defer Close，AsyncIterator → gen.Close）

中断要透传（InterruptRerunError 不能被 Middleware 吞掉）

恢复要对齐（CheckPointStore + CheckPointID 跨 Runner 必须一致）

📂 源码仓库：github.com/cloudwego/eino-examples↗

📖 继续阅读：

入门笔记 — Eino ADK 从 Hello World 到 Compose 编排 ← 你在这里

Agentic 进阶 — Responses API / AgenticMessage / Typed 泛型

附录一：Flow 流程模块 — ReAct Agent / Multi-Agent / 状态图

附录二：Components 组件模块 — A/B 路由 / HTTP 日志 / 检索增强 / 文档解析

附录三：Lambda 与调试工具 — Lambda 写法 / Devops / Mermaid 可视化

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://muxiaowf.dpdns.org/blog/260720eino-note/

Cloudflare Tunnel 将本地服务暴露至公网

MuxiaoWF — Sun, 05 Jul 2026 00:00:00 GMT

最近突然想在手机上也能看到电脑上的文件，找了半天都说需要一个公网ip，对于鄙人白嫖党肯定是不太接受的。最后也是成功找到了一个赛博活佛Cloudflare提供的工具。

感谢 xiaoyuboi/cloudflare-tunnel-skill↗ 提供方法方向，可以直接使用这个 skill 导入 Claude 帮你完成。下文仅当记录了。

一、整体架构

流量链路

1
外部用户 → https://你的域名
2
  → Cloudflare 边缘节点（HTTPS 终止，CDN 缓存）
3
    → Cloudflared  加密隧道（QUIC / HTTP2）
4
      → 本机 127.0.0.1:端口（任意本地 HTTP 服务）

核心思路：本地跑一个 HTTP 服务（文件浏览、API、网站都可以），通过 Cloudflared 隧道暴露到公网，Cloudflare 负责 HTTPS、CDN 和 DDoS 防护。

本文示例

为方便演示，使用 Python 写了一个支持目录导航和前后切换的文件管理器。读者可以替换为任何 HTTP 服务（Node.js、Nginx、网盘程序等）。

tips：ai时代不会的可以直接找ai帮你完成或问ai帮你辅助完成。

我这里使用了固定域名的方式（命名隧道 cloudflared tunnel run <名称>），与临时域名（quick tunnel trycloudflare.com）不同：命名隧道需先完成第三节的初始化（tunnel create + route dns），之后每次启动都用同一个域名。如果你希望每次启动自动获取临时域名，可以使用同目录下的 tunnel_helper.py quick 子命令。本文的 VBS 脚本是按固定域名写法设计的。对于有关Cloudflare域名解析等，可以参考查看之前创建博客的文章。关于没有类似vercel给的DNS配置可以直接跳过，没有问题。

二、前置环境

Python 3：用于运行本地服务
Cloudflared ↗：下载即安装，无界面。可在命令行执行 cloudflared --version 验证
域名 DNS 已托管到 Cloudflare 并生效
推荐：Cloudflare 面板 SSL/TLS → Full，开启「始终使用 HTTPS」

三、隧道初始化（仅首次）

使用 CMD，依次执行：

1
:: 登录 Cloudflare 授权（会弹出浏览器）
2
cloudflared tunnel login
3

4
:: 创建隧道，名称自定（这里叫 pictures）
5
cloudflared tunnel create pictures
6

7
:: 绑定子域名到隧道
8
cloudflared tunnel route dns pictures 你的子域名.你的域名

完成后在 %USERPROFILE%\.cloudflared\ 下会生成隧道凭证 JSON，后续启动隧道时会自动使用，无需上传到 Cloudflare 控制台。

四、本地服务

本地需要运行一个 HTTP 服务监听 127.0.0.1，可以是任意程序：

1
:: 最简单的静态文件服务
2
py -m http.server 3000 --bind 127.0.0.1 --directory F:\share
3

4
:: 或者任何本地 HTTP 服务
5
node server.js
6
nginx -c ...

实际使用时推荐自己写一个服务程序，好处是可以添加：

Range 请求支持（视频拖拽快进）
ETag / 缓存头（减少重复传输）
流式传输（大文件不爆内存）

本文附带的 gallery_server.py 实现了上述优化，同时提供了一个支持目录导航的文件管理器界面。

五、配置文件

将可变参数集中到 config.json，修改端口、目录、域名时无需改动脚本代码：

1
{
2
  "root_dir": "F:\\share",
3
  "port": 3000,
4
  "bind": "127.0.0.1",
5
  "public_url": "https://你的子域名.你的域名"
6
}

Python 服务端通过 --get <key> 子命令暴露配置值，VBS 脚本通过 WshShell.Exec 动态读取：

1
py gallery_server.py --get port
2
:: 输出: 3000
3

4
py gallery_server.py --get running
5
:: 输出: 1（运行中）或 0（未运行）
6

7
py gallery_server.py --kill
8
:: 通过 PID 文件精确终止进程

服务启动后会在 .cloudflare-tunnel\ 下写入 server.pid，用于状态检测和精确终止，避免仅靠端口查杀的不确定性。

六、启动脚本 StartAll.vbs

这是固定域名（命名隧道）的写法。 脚本通过 cloudflared tunnel run pictures 启动预先创建好的命名隧道，使用 --config 指定项目内的 pictures.yml 配置文件，域名固定不变。如果需要每次启动自动获取 trycloudflare.com 临时域名，请使用 tunnel_helper.py quick 子命令。

保存时注意编码选 ANSI（GBK），否则中文弹窗会乱码。

1
Option Explicit
2
Dim WshShell, fso
3
Set WshShell = CreateObject("WScript.Shell")
4
Set fso = CreateObject("Scripting.FileSystemObject")
5
Dim BasePath, port, publicUrl, configPath, cloudflaredExe
6
BasePath = fso.GetParentFolderName(WScript.ScriptFullName)
7
configPath = BasePath & "\.cloudflare-tunnel\pictures.yml"
8

9
' 从配置文件读取参数
10
Function GetConfig(key)
11
    Dim ex, val
12
    Set ex = WshShell.Exec("py """ & BasePath & "\gallery_server.py"" --get " & key)
13
    val = ex.StdOut.ReadLine()
14
    Set ex = Nothing
15
    GetConfig = val
16
End Function
17

18
port = GetConfig("port")
19
publicUrl = GetConfig("public_url")
20
cloudflaredExe = GetConfig("cloudflared_path")
21
If cloudflaredExe = "" Then cloudflaredExe = "cloudflared"
22

23
' Step 1: 查杀残留进程
24
WshShell.Run "cmd /c for /f ""tokens=5"" %a in ('netstat -ano ^| findstr /R ""TCP.*:" & port & "[ ].*LISTENING""') do taskkill /f /pid %a /t >nul 2>&1", 0, True
25
WshShell.Run "taskkill /f /im cloudflared.exe /t >nul 2>&1", 0, True
26
WScript.Sleep 1200
27

28
' Step 2: 启动本地服务（后台静默，无窗口）
29
WshShell.Run "py """ & BasePath & "\gallery_server.py""", 0, False
30

31
' Step 3: 等待服务就绪（轮询 PID 文件 + 进程存活检测，最长 15 秒）
32
Dim maxWait, waited, running
33
maxWait = 15
34
waited = 0
35
Do While waited < maxWait
36
    WScript.Sleep 1000
37
    waited = waited + 1
38
    running = GetConfig("running")
39
    If running = "1" Then Exit Do
40
Loop
41

42
If running <> "1" Then
43
    WshShell.Popup "Gallery server 启动超时（" & maxWait & " 秒）", 10, "启动失败", 16
44
    WScript.Quit 1
45
End If
46

47
' Step 4: 启动命名隧道（固定域名，读取项目内的 pictures.yml 配置）
48
WshShell.Run """" & cloudflaredExe & """ --config """ & configPath & """ --no-autoupdate --protocol quic tunnel run pictures", 0, False
49

50
' Step 5: 弹窗提示
51
Dim msgText
52
msgText = "本地服务 & Cloudflare 隧道已后台运行" & vbCrLf & _
53
          "访问地址：" & publicUrl & vbCrLf & _
54
          "关闭请运行 StopAll.vbs"
55
WshShell.Popup msgText, 8, "启动成功", 64
56

57
Set WshShell = Nothing
58
Set fso = Nothing

启动流程

步骤	动作	说明
Step 1	查杀残留进程	精确匹配端口号边界（`[ ]` 防止 `:3000` 误杀 `:30001`），同时清理上次的 Cloudflared
Step 2	启动 Python 服务	后台静默运行，写入 `server.pid`
Step 3	等待服务就绪	每秒通过 `--get running` 检测进程存活，超时则弹窗报错退出
Step 4	启动命名隧道	使用 `--config` 指定项目内 `pictures.yml`，`--no-autoupdate` 禁止自动更新
Step 5	弹窗提示	显示访问地址，8 秒后自动关闭

关键参数说明

参数	含义
`TCP.*:PORT[ ]`	正则精确匹配端口边界，`[ ]` 确保 `:3000` 不会匹配到 `:30001`，兼容 IPv4/IPv6
`tokens=5`	提取 `netstat -ano` 输出第 5 列（PID）。netstat 输出列序固定，IPv4/IPv6 格式一致
`%a`	`cmd /c` 下 FOR 变量必须单百分号，`%%a` 仅用于 `.bat` 文件
`^\|`	转义管道符，让外层 cmd 将其传递给内层
`0, False`	隐藏窗口 + 不等待返回（后台运行）
`/t`	taskkill 连带子进程一起关闭
`--config`	指定隧道配置文件，命名隧道必加，否则 Cloudflared 不会读取项目内的 ingress 规则
`--no-autoupdate`	禁止 Cloudflared 自动更新，避免后台下载占用带宽
`--protocol quic`	Cloudflared 使用 QUIC 连接边缘节点，比 HTTP2 延迟更低

七、停止脚本 StopAll.vbs

1
Option Explicit
2
Dim WshShell, fso
3
Set WshShell = CreateObject("WScript.Shell")
4
Set fso = CreateObject("Scripting.FileSystemObject")
5
Dim BasePath, port, exec
6
BasePath = fso.GetParentFolderName(WScript.ScriptFullName)
7

8
' 从配置文件读取端口
9
Set exec = WshShell.Exec("py """ & BasePath & "\gallery_server.py"" --get port")
10
port = exec.StdOut.ReadLine()
11
Set exec = Nothing
12

13
' Step 1: 通过 PID 文件精确终止 gallery_server（优先，不会误杀）
14
WshShell.Run "py """ & BasePath & "\gallery_server.py"" --kill", 0, True
15

16
' Step 2: 兜底 —— 按端口查杀残留（防 PID 文件被意外删除）
17
WshShell.Run "cmd /c for /f ""tokens=5"" %a in ('netstat -ano ^| findstr /R ""TCP.*:" & port & "[ ].*LISTENING""') do taskkill /f /pid %a /t >nul 2>&1", 0, True
18

19
' Step 3: 关闭所有 Cloudflared  隧道进程
20
WshShell.Run "taskkill /f /im cloudflared.exe /t >nul 2>&1", 0, True
21

22
WScript.Sleep 400
23
WshShell.Popup "服务已全部关闭", 3, "停止成功", 64
24

25
Set WshShell = Nothing
26
Set fso = Nothing

停止采用三层保障：

优先级	方式	说明
1	`--kill`（PID 文件）	精确终止，不会误杀其他 Python 进程
2	端口查杀（netstat）	兜底方案，防止 PID 文件被意外删除后无法停止
3	进程名查杀（taskkill /im）	关闭所有 Cloudflared .exe

理论上运行后的文件夹下文件

八、隧道配置文件 pictures.yml

命名隧道需要配置文件指定 ingress 规则（哪个域名 → 哪个本地地址）：

1
tunnel: pictures
2
credentials-file: C:\Users\你的用户名\.cloudflared\<tunnel-id>.json
3

4
ingress:
5
  - hostname: 你的子域名.你的域名
6
    service: http://127.0.0.1:3000
7
  - service: http_status:404

credentials-file 是第三节 cloudflared tunnel create 生成的凭证文件路径。如果不指定，Cloudflared 会尝试自动查找，但显式指定更可靠。

九、附：文件管理器 gallery_server.py

本文附带了一个 Python 实现的文件管理器，可作为本地服务的起点或直接使用：

功能：

目录导航（面包屑路径 + ”..” 返回上级）
显示所有文件类型（文件夹、图片、视频、文档等）
文件夹排在前面，点击进入子目录
媒体文件（图片/视频）点击进入全屏查看器，支持上/下一张切换，右上角 X 关闭
非媒体文件点击直接下载，Content-Disposition 头确保浏览器以正确文件名和扩展名保存
键盘 ← → 切换、Esc 返回列表
移动端滑动切换
相邻文件自动预加载（prefetch），切换几乎无等待

运维特性：

PID 文件：启动时写入 .cloudflare-tunnel\server.pid，关闭时自动清理
--get running：检测进程是否存活（Windows 上通过 OpenProcess 查询句柄）
--kill：通过 PID 文件精确终止进程，StopAll.vbs 优先使用此方式
端口占用保护：bind 失败时打印明确错误信息并提示 --kill 命令

性能优化：

HTTP Range 请求（206 Partial Content）：视频可拖拽快进
ETag + Last-Modified：浏览器缓存校验，未改动文件返回 304
流式传输：64KB 分块读取，不将整个文件加载到内存
Cache-Control：媒体文件缓存 1 小时

自定义 favicon： 将 favicon.ico 放到脚本同目录下，自动生效，无需改代码。

通用性： gallery_server.py 只是一个示例本地服务。替换为任何监听 127.0.0.1:端口 的 HTTP 程序，VBS 脚本和隧道配置无需改变。

十、常见问题

1. StopAll.vbs 无法关闭进程

症状： 运行 StopAll.vbs 后，Python 进程和 Cloudflared 仍在运行。

根因： 网上流传的 tokens=-1 是无效的 for /f 语法（CMD 不支持负索引取最后一列），会被静默回退为 tokens=1，提取到的是 TCP 而非 PID。同时 %%a 仅在 .bat 文件中有效，cmd /c 命令行模式必须用 %a。

修复： tokens=5 + %a。（上文脚本已使用正确写法）

2. VBS 中文弹窗显示乱码

根因： 文件编码为 UTF-8，但 VBScript 引擎按系统 ANSI 代码页（中文 Windows 为 GBK）读取。

修复： 用记事本另存为 ANSI 编码，或用 Python 转码：

1
with open('xxx.vbs', 'r', encoding='utf-8') as f:
2
    content = f.read()
3
with open('xxx.vbs', 'w', encoding='gbk') as f:
4
    f.write(content)

3. Cloudflared 报错 “failed to request quick Tunnel”

通常是网络问题或 Cloudflared 版本过旧，升级到最新版即可。

4. 如何更换本地服务程序

修改 StartAll.vbs 中启动本地服务的那一行，将 py gallery_server.py 替换为你的启动命令即可。端口和域名在 config.json 中统一管理。

5. 如何添加其他端口 / 多服务

在 config.json 中增加字段，在 StartAll.vbs 中通过 GetConfig() 读取，复制端口查杀和服务启动的两段代码即可。Cloudflared 支持通过配置文件同时暴露多个服务。

十一、安全说明

--bind 127.0.0.1 确保本地服务仅本机可访问，局域网其他设备无法直连
Python http.server 无上传接口，PUT/DELETE 等方法均不可用，只读安全
--directory 锁定根目录，无法通过 ../ 跨目录读取
Cloudflare 提供免费 DDoS 防护和 SSL 证书
如需更细粒度控制（IP 白名单、速率限制），在 Cloudflare 面板 WAF 中配置

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://muxiaowf.dpdns.org/blog/260705tunnel/

Hadoop学习笔记 -1

MuxiaoWF — Sun, 01 Mar 2026 00:00:00 GMT

Hadoop是什么

海量数据都应经过：先存起来，再将数据拿出来进行计算，并得到结果的过程。但是如果只使用MySQL等数据库将这海量数据存起来，再执行SQL语句进行统计，大概率会因为数据量过大而直接卡死。Hadoop就是一套专门用于大数据处理的工具，其内部由多个组件构成。可以将它理解为应用和大数据之间的一个中间层。

以前我们只需要从一台服务器里读写数据，但一台服务器的储存是有限度的，不可能将所有数据都存放在一台服务器上。因此我们需要在多台服务器里读写数据，但是也不可能每个服务器里只有一个文件，如此巨大的文件的打开读取都费劲。因此我们可以将大文件切分成一个个的小的数据块（也就是block），这样既方便读写又方便备份处理；而这些存放数据的服务器就叫做datanode。

那么这个负责切分和存储数据的分布式软件，HDFS（全名 Hadoop Distributed File System），也就是 Hadoop 的分布式文件系统。

HDFS

现在我们处理好了如何存储数据，接下来应当选择如何才能高效地处理数据。Hadoop的MapReduce是处理数据的核心，它同样将数据切分split成多个小块，将这些小块交给不同的节点进行处理（Map），最后将处理结果汇总起来（Reduce）。

MapReduce

接下来就又有新的问题，MapReduce如何分配数据任务给不同的机器进行处理？YARN（Yet Another Resource Negotiator）是负责统一调度计算资源的调度器，YARN将需要计算的任务抽象为一个个“容器Container”，然后通过“资源申请+协调调度”的方式，将任务分配到一台台计算机上去完成计算任务。

YARN

Hive是一个SQL和MapReduce之间的中间层，它可以将类似SQL的语句转化成map和reduce任务，减少写map()和reduce()代码的工作量。

MapReduce会将中间计算结果缓存在硬盘上，以减少计算资源的消耗，但是将计算结果缓存在硬盘上会带来多次硬盘读写的损耗，因此Spark将中间计算结果优先缓存在内存中，以优化性能。同时Spark可以通过Hive on Spark的中间层，让Hive也可以运用Spark。

左Hive 右Spark

由于Hive on Spark会带来性能损耗，因此又有Spark SQL来直接替代Hive。

至此，对于离线数据（批次处理数据）已经可以正常处理，如果需要处理实时在线数据（来一个处理一个），则可以使用Flink（分钟级别）和Hbase（毫秒级别）。

实战安装

通过这小节，我们将安装Hadoop并配置如下图的三台不同功能的服务器节点。

三台功能不同的服务器

前言准备

这里使用VMware和Ubuntu虚拟机进行接下来的准备，各软件的下载安装请自行完成，vmware↗、Ubuntu清华镜像↗。

安装完成后向VMware中使用经典配置添加虚拟机光盘，这里应当注意第一次安装分配多点内存防止安装卡住（操作完之后可以调小一点）

虚拟机可能的配置

配置完成后，进入虚拟机，安装Ubuntu，这里也是傻瓜式就好了。安装完成后，右键打开命令行尝试获取root权限，并尝试安装Java（不要用他的命令！！！）。

命令1

但是但是但是！！！！这里不要被骗了，使用命令apt-get install openjdk-8-jdk来安装jdk，使用他的会没有后面使用的jps

输入sudo -i或sudo -s命令，然后输入你的用户密码。这两个命令都会让你以root用户的身份启动一个新的shell会话。-i选项会模拟一个完整的root登录，而-s选项只是简单地以root身份启动一个shell。

同时直接在命令前加sudo也可以是使用root用户执行

使用xshell连接虚拟机

接下来使用xshell连接虚拟机，xshell↗下载

开启虚拟机，先使用命令sudo apt install net-tools安装net-tools，并输入ifconfig命令查看IP地址（不是ipconfig）

ifconfig

同时使用命令sudo apt install openssh-server安装openssh-server以启动ssh服务

接下来进行xshell配置，输入上方获得的IP地址并记得在用户身份验证中输入Ubuntu的账号和密码

xshell配置

点击连接即可

xshell连接成功

接下来都在xshell中操作就好了，这样方便复制粘贴。

使用root账号输入nano /etc/default/useradd将文件中的SHELL=/bin/sh改为SHELL=/bin/bash修改创建用户时默认使用bash创建shell

tips：在nano中，按住Ctrl+O并输入回车可以保存，按住Ctrl+X可以退出

配置hadoop

前往hadoop清华镜像站↗下载hadoop并直接拖到虚拟机中（可能需要apt install lrzsz）传输完成后可以使用ll命令列出文件。

hadoop下载

使用tar -zxf hadoop-3.4.3.tar.gz -C /usr/local解压文件，解压后可以使用cd /usr/local/hadoop-3.4.3进入解压后的文件夹。这里先创建一个没有root权限的hadoop用户：

创建hadoop用户（不用管那个密码警告）

这时候使用su - hadoop即可进入hadoop用户，需要注意的是，如果在hadoop用户下不能执行sudo命令，需要转换用户使用（没有添加到sudo组中，限制其权限以保证后续安全性）。

配置文件

使用nano /usr/local/hadoop-3.4.3/etc/hadoop/hadoop-env.sh命令配置环境变量，在最后添加：export JAVA_HOME="/usr/lib/jvm/java-8-openjdk-amd64"（记得修改为自己的Java路径）

使用nano /usr/local/hadoop-3.4.3/etc/hadoop/core-site.xml命令配置HDFS，在标签内输入下述配置（注意下面的ip地址请修改为虚拟机IP地址）：

1
<configuration>
2
    <property>
3
        <name>fs.defaultFS</name>
4
        <value>hdfs://192.168.80.128:8020</value><!--修改为虚拟机IP地址，端口默认8020-->
5
    </property>
6
    <property>
7
        <name>io.file.buffer.size</name>
8
        <value>131072</value>
9
    </property>
10
</configuration>

使用nano /usr/local/hadoop-3.4.3/etc/hadoop/hadoop-env.sh命令添加环境变量（直接写在最上面即可）

1
export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64
2
export HADOOP_HOME=/usr/local/hadoop-3.4.3
3
export HADOOP_CONF_DIR=$HADOOP_HOME/etc/hadoop
4
export HADOOP_LOG_DIR=$HADOOP_HOME/logs

使用nano ~/.bashrc命令添加环境变量（直接写在最上面即可）

1
export HADOOP_HOME=/usr/local/hadoop-3.4.3
2
export PATH=$PATH:$HADOOP_HOME/bin:$HADOOP_HOME/sbin
3
export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64
4
export PATH=$JAVA_HOME/bin:$PATH

环境变量配置

后可以使用source ~/.bashrc命令使环境变量生效。

配置从节点

接下来使用虚拟机克隆克隆多出两个虚拟机作为从节点（内存可以调的比主节点小一点），再分别使用ifconfig查看获取到两个IP地址。同时记得使用nano /usr/local/hadoop-3.4.3/etc/hadoop/core-site.xml命令配置HDFS，将fs.defaultFS下的值修改为各自虚拟机的IP地址。

在主节点使用nano /usr/local/hadoop-3.4.3/etc/hadoop/workers命令配置workers文件，指出从节点的IP地址

1
192.168.80.128 主节点IP
2
192.168.80.129 从节点1
3
192.168.80.130 从节点2

接着使用nano /usr/local/hadoop-3.4.3/etc/hadoop/hdfs-site.xml命令配置三台虚拟机的配置文件：

1
<configuration>
2
    <property>
3
        <name>dfs.datanode.data.dir</name>
4
        <value>700</value><!-- 设置数据目录的权限为 700（只有所有者有读写执行权限）-->
5
    </property>
6
    <property>
7
        <name>dfs.namenode.name.dir</name>
8
        <value>/data/nn</value><!-- NameNode 存储元数据的目录路径 -->
9
    </property>
10
    <property>
11
        <name>dfs.datanode.data.hosts</name>
12
        <value>192.168.80.128,192.168.80.129,192.168.80.130</value><!-- 允许访问 HDFS 的 DataNode 主机列表，指定集群中所有 DataNode 的 IP地址 -->
13
    </property>
14
    <property>
15
        <name>dfs.blocksize</name>
16
        <value>268435456</value><!-- HDFS 数据块大小设置块大小为 256MB（268435456 字节），默认值为 128MB -->
17
    </property>
18
    <property>
19
        <name>dfs.datanode.handle.count</name>
20
        <value>100</value><!-- 设置每个 DataNode 可以同时打开的文件句柄数 -->
21
    </property>
22
    <property>
23
        <name>dfs.datanode.data.dir</name>
24
        <value>/data/dn</value><!-- DataNode 存储实际数据的目录路径 -->
25
    </property>
26
</configuration>

在主节点运行sudo mkdir -p /data/dn和sudo mkdir -p /data/nn命令，创建namenode和datanode的数据目录。在另外两个节点运行sudo mkdir -p /data/dn命令，创建datanode的数据目录（从节点不用创建namenode的数据目录）。

打通SSH

打通ssh，使主节点和从节点之间可以无密码ssh连接。在三个节点均输入ssh-keygen -t rsa -b 4096并不断按回车，创建rsa密钥对。之后输入三次ssh-copy-id + IP命令（IP替换成三个节点的IP地址，包括自己），将分发密钥到其他节点。

ssh配置

注意是在每个节点都输入4条语句。

输入完成后可以尝试使用命令ssh加上其他节点的IP地址进行测试连接

tips：可以使用ctrl+d退出当前用户的登录即退出ssh从而返回

启动

先在三个节点均使用chown -R hadoop:hadoop /usr/local/hadoop-3.4.3和chown -R hadoop:hadoop /data将文件权限改为hadoop所有。这时候所有hadoop的文件都是hadoop用户所有，所以需要使用su - hadoop进入hadoop用户才能继续接下来的操作。

继续使用/usr/local/hadoop-3.4.3/bin/hadoop namenode -format格式化namenode（hadoop namenode -format应该也可以，如果设置好了环境变量的话）。

接下来就可以使用/usr/local/hadoop-3.4.3/bin/hadoop version（或hadoop version）简单检查一下是否配置成功，并在主节点使用/usr/local/hadoop-3.4.3/bin/start-dfs.sh（或start-dfs.sh）启动namenode和datanode（从节点会自动启动datanode），关闭可以使用/usr/local/hadoop-3.4.3/bin/stop-dfs.sh（或stop-dfs.sh）。

接下来使用jps命令查看namenode和datanode的状态。正常情况下，主节点会显示NameNode，SecondaryNameNode和DataNode，从节点会显示DataNode。

主节点jps

从节点jps

tips: 如果在之前已经创建过集群，又再次使用/usr/local/hadoop-3.4.3/bin/hadoop namenode -format格式化namenode，运行发现缺少了datanode/namenode，则可能需要rm -rf /data/dn/*清空数据目录，再重新启动。（或着使用命令备份一下mv /data/dn /data/dn.bak再创建一个新的空目录mkdir -p /data/dn）

之后在真机上浏览器可以使用192.168.80.128:9870（fs.defaultFS里设置的，即主机IP加9870端口）进行测试连接HDFS。

测试连接

单独启动节点

上述为启动所有节点，也可以单独启动节点。单独启动节点需要在对应节点使用hdfs --deamon start|status|stop namenode启动/查看状态/停止namenode，将前面的namenode改为datanode可以启动/查看状态/停止datanode。

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://muxiaowf.dpdns.org/blog/260301hadoop1/

Linux学习笔记

MuxiaoWF — Sun, 01 Mar 2026 00:00:00 GMT

基础Linux命令

Linux没有盘符，所有的文件都保存在根目录下

cd 改变目录
- cd /home/user 改变到指定目录
- cd / 改变到根目录
- cd ../ 改变到上一级目录
- cd ./ 改变到当前目录
- cd ~ 改变到用户目录（例如root用户就相当于cd /root）
- cd - 改变到上一个跳转的目录
pwd 显示当前在哪个目录
ls 列出目录下的文件（单独只有文件名，没有详细信息）
- ls -l 以列表list形式列出目录下的文件（有详细信息，等同于ll）
- ls -a 列出目录下的所有all文件（包括隐藏文件）
- ls -al 以列表list形式列出目录下的所有all文件（有详细信息，等同于-a -l）
- ls /root 列出指定目录下（这里是root目录下）的文件
mkdir 创建目录（make directory）
- mkdir dirname 在当前文件夹下创建目录dirname，若为mkdir /dirname则在根目录下创建目录dirname
- mkdir dirname1 dirname2 在当前文件夹下创建目录dirname1和dirname2
- mkdir -p dirname1/dirname2 在当前文件夹下创建目录dirname1/dirname2，-p表示可以创建父目录即dirname1
touch 创建文件（后面加的内容和mkdir命令一样）
echo 输出，跟其他语言的print一样
- echo "hello world" 输出hello world
- echo "hello world" > file.txt 创建文件并写入内容hello world（覆盖形式）
- echo "hello world" >> file.txt 创建文件并写入内容hello world（追加形式）
- echo $PATH 输出变量PATH的值
cat ，more，less，head，tail 命令均可以查看文件内容
- cat file.txt 输出文件file.txt的内容（所有内容）
- more file.txt 输出文件file.txt的内容（按行显示，enter键查看下一行，q键退出，有进度条）
- less file.txt 输出文件file.txt的内容（按行显示，enter键查看下一行，q键退出，无进度条）
- head file.txt 输出文件file.txt的前10行内容（head -20 file.txt 输出文件file.txt的前20行内容）
- tail file.txt 输出文件file.txt的最后10行内容（tail -20 file.txt 输出文件file.txt的最后20行内容）
- tail -f file.txt 持续输出文件file.txt的最后10行内容（有新内容会追加输出，常用于查看日志文件）
cp 复制文件或目录（copy）
- cp file.txt /home/user 复制文件file.txt到指定目录
- cp -r dirname /home/user 复制目录dirname到指定目录（-r表示递归复制，即复制目录下的所有文件和子目录）
mv 移动文件或目录（move）剪切
- mv file.txt /home/user 移动文件file.txt到指定目录
- mv dirname /home/user 移动目录dirname到指定目录
- mv dirname1 dirname2 重命名目录dirname1为dirname2（如果dirname2已存在，则将dirname1的内容移动到dirname2 中。不存在的话就相当于重命名）
rm 删除文件或目录（remove）
- rm file.txt 删除文件file.txt
- rm -r dirname 删除目录dirname及其内容（-r表示递归删除）
- rm -rf dirname 删除目录dirname及其内容（-rf表示递归删除且不提示确认，强制force删除）
vi file.txt 编辑文件file.txt
- 进入文件后需要先按i进入编辑模式insert
- 编辑完后需要按Esc键退出编辑模式
- 在非其他模式下输入:wq 保存并退出（:w保存，:q退出，:wq!强制保存并退出）
- vim 也是编辑器，对于代码可以高亮，需要安装其他包
gzip、tar 压缩文件
- gzip file.txt 压缩文件file.txt（会自动生成file.txt.gz文件并删除源文件）
- gzip -d file.txt.gz 解压文件file.txt.gz（会自动删除源文件）
- gzip -k file.txt 压缩文件file.txt（不会删除源文件）
- tar -zcvf file.tar.gz dirname 压缩目录dirname（会自动生成file.tar.gz文件并删除源目录）
- tar -xvf file.tar -C /home/file 解压文件file.tar到指定目录/home/file
- zip 也是压缩文件，但是需要安装其他包
yum install -y package CentOS安装软件（apt install -y package Ubuntu）
grep 查找
- grep -n string file.txt 在文件file.txt中查找字符串string并显示行号（-n）
- grep -i string file.txt 在文件file.txt中查找字符串string并忽略大小写（-i）
- grep -v string file.txt 在文件file.txt中查找字符串string并取反结果（-v）
- ls | grep string 在ls命令结果下搜索字符串string（ls可以换成其他命令如ps -ef等）
date 显示当前时间
- date -s "2026-01-03 12:00:00" 设置时间
- ntpdate time1.aliyun.com 同步时间
scp 远程拷贝文件（两台机器之间拷贝文件）
- scp file.txt user@remote_host:/home/user 拷贝文件 file.txt 到远程主机 remote_host（用用户名 user 登录远程主机）的 /home/user 目录下
chmod 修改文件权限
- chmod 755 file.txt 修改文件 file.txt 的权限为 755（所有者可读写执行，其他人可读执行）
- chmod +x script.sh 给脚本添加执行权限
- chmod -R 755 dirname 递归修改目录下所有文件的权限
chown 修改文件所有者
- chown user file.txt 将文件 file.txt 的所有者改为用户 user
- chown user:group file.txt 将文件 file.txt 的所有者改为 user，所属组改为 group
- chown -R hadoop:hadoop /usr/local/hadoop 递归修改目录所有者和所属组
sudo 以管理员权限执行命令
- sudo apt install package 以管理员权限安装软件包
- sudo -i 切换到 root 用户（模拟完整登录）
- sudo -s 切换到 root 用户的 shell
su 切换用户
- su - username 切换到 username 用户并加载其环境变量
- su username 切换到 username 用户但不加载环境变量
ps 查看进程状态
- ps -ef 显示所有进程的详细信息
- ps aux 显示所有进程的详细信息（更常用）
- ps -ef | grep java 查找所有 Java 进程
kill 终止进程
- kill PID 发送默认信号终止进程（需要提供进程 ID）
- kill -9 PID 强制终止进程
- killall process_name 根据进程名终止进程
top/htop 实时监控系统资源
- top 实时显示进程和资源使用情况（按 q 退出，按 P 按 CPU 排序，按 M 按内存排序）
- htop 更直观的监控工具（需要安装）
df 查看磁盘空间使用情况
- df -h 以人类可读格式显示磁盘使用情况（GB、MB 等）
- df -T 显示文件系统类型
du 查看目录大小
- du -sh dirname 查看目录 dirname 的总大小
- du -ah dirname 显示目录下所有文件和目录的大小
- du --max-depth=1 dirname 显示目录下第一级子目录的大小
find 查找文件
- find /home -name "file.txt" 在 /home 目录下查找名为 file.txt 的文件
- find . -type f -name "*.log" 在当前目录下查找所有 .log 文件
- find /var/log -mtime -7 查找 /var/log 目录下 7 天内修改过的文件
ln 创建软链接
- ln -s /path/to/source /path/to/link 创建源文件的软链接（类似 Windows 快捷方式）
- ln source link 创建硬链接
netstat/ss 查看网络连接状态
- netstat -tuln 查看所有监听的 TCP 和 UDP 端口
- netstat -an | grep 8080 查看 8080 端口的连接情况
- ss -tuln 更现代的查看网络状态命令
man 查看帮助文档
- man ls 查看 ls 命令的详细帮助
- man 5 passwd 查看配置文件格式说明（5 表示章节）
jps 查看 Java 进程（JDK 自带）
- jps 显示所有 Java 进程及其进程 ID
- jps -l 显示完整的类名或 JAR 文件名
- jps -v 显示 JVM 启动参数

通过使用“（tab上面的那个）来执行命令，例如echo `ls /home/`会将/home/目录下的所有文件列出来（相当于先执行了ls /home/再输出）

Shell脚本

touch file.sh 创建脚本文件

vi file.sh 编辑脚本文件

sh file.sh 执行脚本文件（或使用chmod +x file.sh授权可以执行再./file.sh）

r 可读，w 可写，x 可执行

在文件中可以使用指代$0：脚本名字，$1：第一个参数，$2：第二个参数，…，$#：参数个数，$*：以字符串的形式展示所有参数，$@：以数组形式展示所有参数

之后可以直接使用sh file.sh var1 var2执行脚本文件，其中var1和var2是传递给脚本的参数

注意，在编写脚本时，请务必使用#!/bin/bash作为脚本文件的开头，并使用UNIX+UTF-8进行编码保存。

等号附近注意不要随意添加空格，赋值不能有空格（视为一个整体），比较要有空格（视为分开的部分）

基础

变量

变量声明：variable_name="value"，注意变量名等号值之间不能有空格，其余规则同其他语法

赋值后变量名前加${}，如${variable_name}就可以获取到变量值（可以不用添加{}）

使用unset命令可以删除变量，如unset variable_name，删除后再次echo会没有任何输出

字符串

建议使用双引号，双引号其中可以有变量（v="string${var1}"，var1会自动替换为var1的值）且可以出现转义字符

单引号 '：内容原样输出，不支持变量替换
双引号 "：支持变量替换和转义字符
反引号 `：命令执行（更推荐用 $()）

字符串拼接：string1="hello" string2="world" echo ${string1} ${string2}

在变量前添加#来获取字符串长度：echo ${#string}

截取字符串：echo ${string:1:4}，从索引1开始截取4个字符；echo ${string:4}，去掉字符串前4个字符

控制台输入

read命令可以获取用户输入：read var1 var2，var1和var2为变量名，输入的内容会自动赋给变量var1和var2

read -p "请输入：" var1 输入内容后回车，会自动打印提示信息并赋给变量var1

表达式

shell脚本中可以使用expr命令进行表达式加减乘除计算，如expr 1 + 2，注意运算符之间需要有空格（不能写成expr 1+2）。其中乘法需要使用转义字符\*，如expr 2 \* 3。

同时也可以使用 $(()) 代表表达式，如 echo $(( 1 + 2))；或者使用 $[]，如 echo $[ 1 + 2 ]。在 $(()) 和 $[] 中可以直接使用数学运算符 +、-、*、/、%，以及比较运算符 >、<、>=、<=、==、!=，无需转义。

在 $(()) 中变量可以不加 $ 符号，如 echo $((a + b))
$(()) 支持自增自减：((i++))、((i--))
let 命令：let a=1+2 或 let i++

在 test 命令或 [ ] 条件测试中，字符串比较使用 ==、!=，数值比较则需要使用：-eq 等于、-ne 不等于、-gt 大于、-lt 小于、-ge 大于等于、-le 小于等于。

&& 逻辑与，|| 逻辑或

数组

数组声明：array=(element1 element2 element3 ...)，注意数组名与等号之间不能有空格，数组元素之间用空格或逗号隔开。同时shell中只有一维数组，即不能嵌套数组

获取数组元素：echo ${array[index]}，获取数组所有元素：echo ${array[*]}，获取数组长度：echo ${#array[*]}（*可以替换成@，与上文说的传参一致）。

条件语句

使用if elif else fi 来创建条件语句

1
if [ $a -gt $b ]; then
2
  echo "a 大于 b"
3
elif [ $a -eq $b ]; then
4
  echo "a 等于 b"
5
else
6
  echo "a 少于 b"
7
fi

循环语句

使用for in do done 来创建循环语句

1
for i in 1 2 3 4 5; do
2
  echo $i
3
done
4

5

6
for i in {1..10}; do
7
  echo $i
8
done
9

10
arr=(a,b,c)
11
len = ${#arr[@]}
12
for ((i=0; i < $len; i++)); do
13
  echo ${arr[$i]}
14
done
15

16
for i in $arr; do
17
  echo $i
18
done

写一个脚本，实现将文件夹下的所有文件授权：

1
a=`ls $1`
2
for file in $a; do
3
  chmod u+x $file
4
  echo "授权成功：$file"
5
done

使用while do done 来创建循环语句

1
i=1
2
while [ $i -le 5 ]; do
3
  echo $i
4
  ((i++))
5
done

使用until do done 来创建循环语句（循环直到条件满足时结束）

1
i=1
2
until [ $i -gt 5 ]; do
3
  echo $i
4
  ((i++))
5
done

与其他语言一样，在循环中使用break可以跳出循环，continue跳过本次循环

case

使用case esac 来创建条件语句

1
case $1 in
2
    1)  echo '你选择了 1'
3
    ;;
4
    2)  echo '你选择了 2'
5
    ;;
6
    3)  echo '你选择了 3'
7
    ;;
8
    4)  echo '你选择了 4'
9
    ;;
10
    *)  echo '你没有输入 1 到 4 之间的数字'
11
    ;;
12
esac
13

14

15
case "$2" in
16
   "muxiao") echo "暮晓"
17
   ;;
18
   "blog") echo "博客"
19
   ;;
20
   "hello") echo "你好"
21
   ;;
22
esac

函数

1
function function_name() {
2
  echo "hello world"
3
}
4

5
function_name

调用函数时不需要添加括号，同样的如果需要带参数也不用在函数定义的时候添加

1
function function_name() {
2
  echo "$1"
3
}
4

5
function_name "hello world"

可以看到脚本中函数的传参和在控制台中传参一样。如果函数需要返回值，则需要使用return关键字

1
function function_name() {
2
  return $1
3
}
4

5
a=$(function_name 1)
6
echo $a

脚本的互相调用

使用source ./file.sh来调用脚本，但是要注意需要使用绝对路径或相对路径

1
source ./file1.sh
2
source /path/to/file2.sh

这样就可以使用file1.sh、file2.sh中的变量并同时运行file1.sh、file2.sh中的脚本了（就是相当于将file1.sh和file2.sh中的脚本复制到了这里）

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://muxiaowf.dpdns.org/blog/260301linux/

评论聊

MuxiaoWF — Wed, 03 Sep 2025 00:00:00 GMT

评论聊

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://muxiaowf.dpdns.org/blog/250903comment/

深度学习笔记：术语表

MuxiaoWF — Mon, 01 Sep 2025 00:00:00 GMT

这是深度学习笔记系列的配套术语表。每个术语都附带通俗解释和首次出现的文章链接，方便随时查阅。

建议配合系列文章使用——术语表帮你快速回忆，文章帮你深入理解。

第1篇相关：多项式拟合、概率论与信息论

第1篇 | 覆盖Ch1-2

术语	英文	通俗解释
误差函数	Error Function	衡量模型预测值和真实值之间差距的函数，越小说明模型画的线离数据点越近
过拟合	Overfitting	模型太复杂，把数据里的随机噪声也当规律学进去了，在新数据上表现很差
欠拟合	Underfitting	模型太简单，连数据的基本规律都没学到
正则化	Regularization	给模型参数加惩罚项，防止参数过大导致过拟合，就像给模型加了个”紧箍咒”
权重衰减	Weight Decay	正则化的另一种叫法，因为惩罚项会让权重在训练过程中不断”缩小”
交叉验证	Cross-Validation	把数据分成多份轮流训练和验证，公平评估模型性能的方法
超参数	Hyperparameter	训练前需要人工设定的参数（如学习率、网络层数），不是模型自己学出来的
激活函数	Activation Function	对神经元的加权求和结果做非线性变换的函数，常用的有ReLU、sigmoid、tanh
预激活	Pre-activation	神经元的加权求和结果，就是把输入各自乘上权重加起来，但还没过激活函数
多层感知机	Multi-Layer Perceptron (MLP)	由多层神经元组成的神经网络，层数越多能学到的模式越复杂
概率密度函数	Probability Density Function (PDF)	描述连续变量在某点附近概率大小的函数，曲线下的面积代表概率
先验概率	Prior	观测数据之前对事件概率的信念，比如”根据天气预报，下雨概率30%”
后验概率	Posterior	观测数据之后更新的事件概率，比如”看到地面湿了之后，下雨概率变成73%”
似然	Likelihood	给定参数下观测到数据的概率，用来判断哪组参数最能解释现有数据
最大似然估计	Maximum Likelihood Estimation (MLE)	找到最可能产生观测数据的参数值——“哪组参数让数据出现的概率最大”
熵	Entropy	衡量随机变量不确定性或”混乱度”的指标，越不确定熵越大
KL散度	Kullback-Leibler Divergence	衡量两个概率分布之间差异的指标，值越大说明两个分布越不同
互信息	Mutual Information	衡量两个变量之间共享信息量的指标，值越大说明两个变量越相关
频率学派	Frequentist	认为概率就是”反复做很多次实验，某件事发生的频率”，参数是固定但未知的
贝叶斯学派	Bayesian	认为概率是”我们对某件事发生的相信程度”，通过贝叶斯定理更新信念
偶然不确定性	Aleatoric Uncertainty	数据本身固有的噪声（如测量误差），无法通过增加数据消除
认知不确定性	Epistemic Uncertainty	因数据不足导致的不确定性，数据越多越小
累积分布函数	Cumulative Distribution Function (CDF)	$P(z) = \int_{-\infty}^z p(x)dx$ ，表示” $x$ 小于等于 $z$ 的概率”
经验分布	Empirical Distribution	在每个观测数据点处放一根高度为 $1/N$ 的”针”来近似真实分布的做法
精度	Precision	方差的倒数 $1/\sigma^2$ ，精度越大说明分布越集中
雅可比矩阵	Jacobian Matrix	由向量函数所有一阶偏导数组成的矩阵，行列式的绝对值表示变换前后的体积缩放比例
雅可比因子	Jacobian Factor	概率密度变量变换时的缩放因子 $\\|dg/dy\\|$ ，确保变换后总概率守恒
Jensen不等式	Jensen’s Inequality	对凸函数 $f$ ： $f(E[x]) \leq E[f(x)]$ ，用于证明KL散度非负

第2篇相关：概率分布与线性回归

第2篇 | 覆盖Ch3-4

术语	英文	通俗解释
伯努利分布	Bernoulli Distribution	描述抛硬币这种只有两种结果（正面/反面）的概率分布
多项式分布	Multinomial Distribution	掷骰子这种有多种结果的概率分布，是伯努利分布的推广
高斯分布/正态分布	Gaussian / Normal Distribution	最常见的”钟形曲线”分布，自然界中很多现象都近似服从它
协方差	Covariance	衡量两个变量一起变化的程度——正协方差说明同增同减，负协方差说明此增彼减
矩	Moments	描述分布形状的统计量：一阶矩是均值（重心），二阶矩与方差（分散程度）相关
偏差-方差权衡	Bias-Variance Tradeoff	模型简单则偏差高（打偏了）方差低（很稳定），复杂则偏差低（打得准）方差高（忽左忽右）
线性回归	Linear Regression	用一条直线（或超平面）来拟合数据的最简单回归模型
高斯混合模型	Gaussian Mixture Model (GMM)	K个高斯分布加权混合，可以逼近任意连续密度函数
指数族分布	Exponential Family	把各种常见分布（伯努利、高斯、泊松等）用统一”模板”写出的数学框架
充分统计量	Sufficient Statistic	概括数据所有信息的函数，知道它就够了，原始数据可以丢掉
自然参数	Natural Parameter	指数族分布标准形式中的参数向量，是原始参数的变换
核密度估计	Kernel Density Estimation (KDE)	在每个数据点放一个”小山丘”叠加起来估计密度的非参数方法
基函数	Basis Function	对输入特征做固定的非线性变换（如 $x \to x^2$ ），把线性模型扩展为非线性
正规方程	Normal Equation	线性回归的闭式解： $\mathbf{w} = (\mathbf{\Phi}^T\mathbf{\Phi})^{-1}\mathbf{\Phi}^T\mathbf{t}$
设计矩阵	Design Matrix	每行是样本的基函数值组成的矩阵 $\mathbf{\Phi}$ ，线性回归的核心
马哈拉诺比斯距离	Mahalanobis Distance	考虑特征间相关性的”距离”度量，协方差矩阵为单位矩阵时退化为欧氏距离
决策理论	Decision Theory	用损失函数量化预测代价，从概率模型中做出最优决策的框架

第3篇相关：分类与深度神经网络

第3篇 | 覆盖Ch5-6

术语	英文	通俗解释
判别函数	Discriminant Function	直接输出分类决策的函数——输入数据，输出”属于哪个类别”
决策边界	Decision Boundary	分类器将不同类别分开的分界线，就像地图上的省界
1-of-K编码 / One-Hot编码	One-Hot Encoding	用长度为K的向量表示K个类别，只有对应位置为1其余为0，比如类别2→[0,1,0,0,0]
逻辑斯谛回归	Logistic Regression	用sigmoid函数做二分类的模型，虽然名字带”回归”但其实是分类方法
Sigmoid函数	Sigmoid Function	把任意实数压缩到0~1之间的S形曲线函数，输出可以解释为概率
Softmax函数	Softmax Function	把多个实数转换成概率分布的函数，确保所有输出加起来等于1
交叉熵	Cross-Entropy	衡量分类预测和真实标签差异的损失函数，预测越准交叉熵越小
生成模型	Generative Model	先学习每个类别的数据”长什么样”，再用贝叶斯定理分类
判别模型	Discriminative Model	直接学习”怎么区分不同类别”，不关心每个类别具体长什么样
混淆矩阵	Confusion Matrix	展示分类器在各类别上预测结果的表格，能看出哪类容易被搞混
ROC曲线	ROC Curve	绘制不同阈值下真阳性率和假阳性率的曲线，越靠近左上角越好
维度灾难	Curse of Dimensionality	高维空间中数据变得极其稀疏，低维的直觉在高维中完全失效
数据流形	Data Manifold	高维数据实际分布的低维结构——比如手写数字图片虽然有784维，但实际变化只有几个因素
残差连接	Residual Connection	允许信息绕过某些层直接传递的连接方式，帮助训练非常深的网络
迁移学习	Transfer Learning	在一个任务上学到的知识用到另一个相关任务上，比如用ImageNet预训练的模型做医学图像分类
张量	Tensor	多维数组的统称——标量是0维、向量是1维、矩阵是2维，更高维的叫张量
混合密度网络	Mixture Density Network (MDN)	能输出多个可能结果（而非单一预测）的网络，适用于一个输入对应多个合理输出的情况
朴素贝叶斯分类器	Naive Bayes Classifier	假设所有特征在给定类别下条件独立的生成分类器
线性判别分析	Linear Discriminant Analysis (LDA)	假设各类别共享同一协方差矩阵的生成分类器，产生线性决策边界
二次判别分析	Quadratic Discriminant Analysis (QDA)	各类别允许有各自协方差矩阵的生成分类器，产生二次决策边界
径向基函数网络	Radial Basis Function (RBF) Network	以训练样本为中心放置局部基函数的网络
表示学习	Representation Learning	自动学习输入数据的有效表示，而非依赖人工设计的特征
对比学习	Contrastive Learning	通过拉近相似样本、推远不相似样本来学习表示的自监督方法
残差网络	Residual Network (ResNet)	使用跳跃连接绕过某些层的深层网络，使得训练非常深的网络成为可能
前向传播	Forward Propagation	输入逐层通过网络计算输出的过程
数据增强	Data Augmentation	通过对现有样本做变换（旋转、裁剪、翻转）来人工扩充训练数据
AUC	Area Under ROC Curve (AUC)	ROC曲线下的面积，0.5=随机猜测，1.0=完美分类
F-score	F-score (F1)	精确率和召回率的调和平均数，综合衡量分类性能

第4篇相关：梯度下降、反向传播与正则化

第4篇 | 覆盖Ch7-9

术语	英文	通俗解释
梯度	Gradient	函数在某点变化最快的方向和速率——站在山上，梯度指向最陡的上坡方向
学习率	Learning Rate	控制每次参数更新步长大小的超参数——步子太大容易跨过最优解，太小则训练太慢
随机梯度下降	Stochastic Gradient Descent (SGD)	每次只用一部分数据估计梯度，比用全部数据快很多但噪声更大
动量	Momentum	让优化器有”惯性”，帮助冲过局部最小值和鞍点
Adam优化器	Adam Optimizer	结合动量和自适应学习率的优化算法，是目前最常用的优化器之一
反向传播	Backpropagation	从输出层到输入层逐层计算梯度的算法，是训练神经网络的核心
链式法则	Chain Rule	复合函数求导的法则——反向传播的数学基础
Dropout	Dropout	训练时随机”关闭”一部分神经元的正则化技术，防止过拟合
批量归一化	Batch Normalization	对每一层的输入做标准化处理，让训练更快更稳定
权重初始化	Weight Initialization	训练开始前给参数赋初始值的方法，好的初始化能让训练更顺利
梯度消失/爆炸	Vanishing/Exploding Gradients	深层网络中梯度在传递过程中变得极小或极大的问题
早停	Early Stopping	当验证集误差不再下降时提前停止训练的正则化方法
Hessian矩阵	Hessian Matrix	误差函数对所有参数的二阶偏导数组成的方阵，描述误差曲面的局部弯曲程度
AdaGrad	Adaptive Gradient	通过累积梯度平方来自适应调整每个参数学习率的优化器，适合稀疏特征
RMSProp	Root Mean Square Propagation	用指数加权移动平均改进AdaGrad的优化器，能”忘记”早期梯度
指数加权移动平均	Exponential Moving Average (EMA)	近期数据权重更大、远期数据逐渐”遗忘”的平均方法
层归一化	Layer Normalization	对单个样本的所有特征做归一化（不同于批量归一化跨样本归一化），Transformer中常用
自动微分	Automatic Differentiation	将任意可微程序分解为基本运算来精确计算梯度的技术
归纳偏置	Inductive Bias	学习算法对目标函数所做的假设集合，决定了模型如何从有限数据泛化
双重下降	Double Descent	测试误差先降后升（经典偏差-方差区间）再降（过参数化区间）的现代现象
集成方法	Ensemble Method	组合多个模型的预测来获得比单个模型更好的泛化性能

第5篇相关：卷积网络与概率图模型

第5篇 | 覆盖Ch10-11

术语	英文	通俗解释
卷积	Convolution	用一个小的滤波器在输入上滑动，提取局部特征——就像用放大镜逐块扫描图片
滤波器/卷积核	Filter / Kernel	卷积操作中用于提取特征的小矩阵，不同的核提取不同的特征（边缘、纹理等）
池化	Pooling	对特征图做下采样，缩小尺寸保留主要特征——就像把照片缩小但还能看清内容
特征图	Feature Map	卷积操作的输出，表示在不同位置检测到的特征
感受野	Receptive Field	输出特征图上一个点对应输入图像的区域大小
概率图模型	Probabilistic Graphical Model	用图结构（节点和边）表示变量间概率关系的模型
贝叶斯网络	Bayesian Network	用有向图表示因果关系的概率图模型——箭头表示”因为A所以B”
马尔可夫随机场	Markov Random Field	用无向图表示相关关系的概率图模型——连线表示”A和B相关”
d-分离	d-separation	判断贝叶斯网络中两个变量是否条件独立的方法
平移等变性	Translation Equivariance	输入平移时输出也平移同样距离——CNN不管特征在图像哪个位置都能检测到
全卷积网络	Fully Convolutional Network (FCN)	用1×1卷积替换全连接层，能处理任意大小输入的网络
转置卷积	Transposed Convolution	可学习的上采样操作，将低分辨率特征图映射回高分辨率
上采样	Up-sampling	增加特征图空间分辨率的操作，用于分割和生成任务
U-Net	U-Net	对称的编码器-解码器架构，通过跳跃连接保留空间细节，用于语义分割
跳跃连接	Skip Connection	将编码器层直接连到对应解码器层，保留下采样丢失的空间细节
显著性图	Saliency Map	可视化技术，显示输入图像的哪些区域对分类决策影响最大
对抗性攻击	Adversarial Attack	对输入添加人眼不可察觉的微小扰动，导致网络做出完全错误的预测
风格迁移	Style Transfer	用CNN特征将一张图的”内容”和另一张图的”风格”组合起来
马尔可夫链	Markov Chain	下一步只取决于当前状态的随机过程（无记忆性）
隐马尔可夫模型	Hidden Markov Model (HMM)	观测数据由形成马尔可夫链的隐藏状态生成的模型
状态空间模型	State-Space Model	观测数据依赖于随时间演化的潜变量的通用框架

第6篇相关：Transformer与图神经网络

第6篇 | 覆盖Ch12-13

术语	英文	通俗解释
注意力机制	Attention Mechanism	让模型动态地为不同输入分配不同重要性权重——读文章时自动关注重点段落
自注意力	Self-Attention	Query、Key、Value都来自同一输入序列的注意力，让序列中的每个元素都能”看到”其他所有元素
Query / Key / Value	Query / Key / Value	注意力中的三个角色：Query是”我在找什么”，Key是”我有什么标签”，Value是”我的实际内容”
多头注意力	Multi-Head Attention	多个并行的注意力头，每个头关注不同类型的依赖关系（语法、语义等）
位置编码	Positional Encoding	给输入序列加上位置信息，因为自注意力本身不区分顺序
Transformer	Transformer	基于自注意力机制的深度学习架构，是现代NLP和多模态模型的基础
词嵌入	Word Embedding	将词映射到低维稠密向量的技术，语义相近的词在向量空间中距离也近
分词	Tokenization	将文本切分成token（词、子词或字符）的过程
BERT	BERT	双向编码器，通过”完形填空”式预训练学习语言理解
GPT	GPT	生成式预训练Transformer，通过”预测下一个词”式预训练学习文本生成
图神经网络	Graph Neural Network (GNN)	处理图结构数据（分子、社交网络等）的神经网络
消息传递	Message Passing	GNN中节点聚合邻居信息的机制——每个节点从邻居那里”收集情报”然后更新自己
过平滑	Over-Smoothing	GNN层数过多后节点表示趋于相同的问题——“近朱者赤近墨者黑”到最后大家都一样
邻接矩阵	Adjacency Matrix	用矩阵表示图中哪些节点之间有边相连
置换不变性	Permutation Invariance	输出不随输入节点排列顺序改变而改变的性质
束搜索	Beam Search	每步保留B个最优候选序列的解码策略，平衡搜索质量和计算量
温度参数	Temperature Parameter	控制softmax采样随机性的参数——越低越确定，越高越随机
掩码注意力	Masked Attention	阻止token关注未来位置的注意力机制，用于自回归解码器
交叉注意力	Cross-Attention	Q来自解码器、K和V来自编码器输出的注意力，桥接编码器和解码器
大语言模型	Large Language Model (LLM)	在海量文本上预训练的超大规模Transformer模型，能完成各种语言任务
低秩适应	Low-Rank Adaptation (LoRA)	冻结预训练权重、只训练低秩矩阵的微调方法，可训练参数减少几个数量级
提示工程	Prompt Engineering	通过设计输入提示引导大语言模型完成任务，无需更新权重
视觉Transformer	Vision Transformer (ViT)	将图像切成patch当作token，用Transformer处理图像的架构
梅尔频谱图	Mel Spectrogram	用感知均匀的频率尺度将音频波形转换为时频矩阵
图注意力网络	Graph Attention Network (GAT)	用注意力动态加权不同邻居重要性的GNN变体
聚合算子	Aggregation Operator	GNN消息传递中用于合并邻居信息的函数（求和、均值、最大值）
置换等变性	Permutation Equivariance	节点级预测随节点排列顺序一致变化的性质，GNN必须满足
字节对编码	Byte Pair Encoding (BPE)	迭代合并最频繁相邻字符对的分词方法，直到达到目标词表大小

第7篇相关：采样方法与潜变量模型

第7篇 | 覆盖Ch14-16

术语	英文	通俗解释
蒙特卡洛方法	Monte Carlo Methods	用大量随机实验来近似计算的方法——比如通过随机投点估算圆周率
马尔可夫链蒙特卡洛	Markov Chain Monte Carlo (MCMC)	通过构建一个”随机游走”过程来采样的方法，走的步数够多后分布会收敛到目标分布
潜变量/隐变量	Latent Variable	数据中存在但观测不到的隐藏因素——比如你看到一个人的表情（观测），推测他的心情（潜变量）
K-means聚类	K-Means Clustering	将数据分成K个簇的无监督学习算法——“物以类聚”
EM算法	Expectation-Maximization	处理含隐变量模型的迭代优化算法——先猜测隐变量（E步），再优化参数（M步），反复循环
主成分分析	Principal Component Analysis (PCA)	找到数据最大方差方向进行降维的方法——就像给3D物体找最佳的2D投影角度
证据下界	Evidence Lower Bound (ELBO)	对数似然的一个可优化的”保底”下界，VAE训练的核心目标函数
变分推断	Variational Inference	用一个简单的分布去近似复杂的后验分布的推断方法
拒绝采样	Rejection Sampling	从”包络”分布中采样，根据是否落在目标密度下方来接受或拒绝
提议分布	Proposal Distribution	拒绝采样和MCMC中用于提议候选样本的”替身”分布
接受概率	Acceptance Probability	拒绝采样和MCMC中接受一个提议样本的概率，直接影响采样效率
能量模型	Energy-Based Model	通过能量函数定义概率： $p(x) \propto e^{-E(x)}$ ，能量越低概率越高
配分函数	Partition Function	能量模型中的归一化常数 $Z$ ，需要对整个空间积分，通常难以计算
白化	Whitening	将数据变换为零均值、单位协方差、各维度不相关的预处理步骤
因子分析	Factor Analysis	类似概率PCA但允许每个观测维度有各自的噪声方差（对角协方差）
独立成分分析	Independent Component Analysis (ICA)	假设潜变量是统计独立的非高斯变量，用于盲源分离
卡尔曼滤波器	Kalman Filter	潜变量形成马尔可夫链的序列数据状态空间模型，用于跟踪和时间序列
去量化	Dequantization	通过加均匀噪声将离散观测转为连续变量，防止密度坍缩到整数点

第8篇相关：GAN、标准化流、自编码器与扩散模型

第8篇 | 覆盖Ch17-20

术语	英文	通俗解释
生成对抗网络	Generative Adversarial Network (GAN)	生成器和判别器对抗训练的生成模型——造假者和鉴定师互相博弈，最终造假者能造出以假乱真的作品
生成器	Generator	GAN中负责生成假数据的网络，目标是骗过判别器
判别器	Discriminator	GAN中负责判断数据真假的网络，目标是识破生成器
标准化流	Normalizing Flows	通过一系列可逆变换将简单分布变成复杂分布的生成模型——就像把一团橡皮泥捏成复杂形状
自编码器	Autoencoder	将输入压缩到低维表示再重建的网络，学习数据的”精华摘要”
变分自编码器	Variational Autoencoder (VAE)	在自编码器中引入概率建模的生成模型，能生成新数据而不仅仅是重建
扩散模型	Diffusion Model	通过逐步去噪来生成数据的模型——先把图片完全变成噪声，再学习怎么一步步恢复回来
前向过程	Forward Process	扩散模型中逐步给数据加噪声的过程，直到变成纯噪声
反向过程	Reverse Process	扩散模型中逐步去噪恢复数据的过程，这就是生成新数据的过程
噪声预测	Noise Prediction	扩散模型的核心思想——不直接预测图片，而是预测”加了什么噪声”，然后把噪声减掉
向量量化	Vector Quantization	将连续向量映射到离散码本中最近的码字，用于VQ-VAE等模型
得分函数	Score Function	指向概率密度增大方向的向量——告诉你往哪个方向走能找到更高概率的区域
模式崩溃	Mode Collapse	GAN训练失败——生成器只产出少数几种输出，忽略了完整数据分布
Wasserstein距离	Wasserstein Distance	衡量把一个分布”搬”成另一个分布的最小”工作量”，即使分布不重叠也有意义
循环一致性损失	Cycle Consistency Loss	CycleGAN中确保A→B→A能还原原图的损失，实现无配对图像翻译
耦合流	Coupling Flow	可控的标准化流设计（如Real NVP），一部分输入基于另一部分做变换
掩码自回归流	Masked Autoregressive Flow (MAF)	似然计算快但采样慢的自回归流
逆自回归流	Inverse Autoregressive Flow (IAF)	采样快但似然计算慢的自回归流，MAF的计算特性反转
重参数化技巧	Reparameterization Trick	将随机性从参数中分离（ $\mathbf{z} = \mathbf{\mu} + \mathbf{\sigma} \cdot \mathbf{\epsilon}$ ），使VAE中梯度能通过采样反向传播
去噪自编码器	Denoising Autoencoder	从损坏的输入恢复干净输入来学习鲁棒表示，扩散模型的概念前身
掩码自编码器	Masked Autoencoder (MAE)	用大面积掩码+Transformer的图像去噪自编码器
引导扩散	Guided Diffusion	在扩散生成中加入引导信号，控制生成朝期望方向（如特定类别或文本描述）进行
无分类器引导	Classifier-Free Guidance	同时训练条件和无条件生成，推理时控制混合比例，Stable Diffusion的主流方法
潜扩散模型	Latent Diffusion Model	在压缩的潜空间而非像素空间运行扩散过程，大幅降低高分辨率图像的计算量
对比散度	Contrastive Divergence	能量模型的训练算法，用短链采样近似似然梯度，避免计算配分函数
朗之万动力学	Langevin Dynamics	结合得分函数梯度上升和随机噪声扰动的采样方法
去噪得分匹配	Denoising Score Matching	通过学习去噪来训练得分函数估计器，等价于扩散模型的训练目标
扩散核	Diffusion Kernel	条件分布 $q(z_t
随机微分方程	Stochastic Differential Equation (SDE)	离散扩散过程的连续时间极限，统一了扩散模型、得分匹配和朗之万动力学
神经常微分方程	Neural ODE	将神经网络视为连续动力系统而非离散层，通过ODE求解器定义网络

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://muxiaowf.dpdns.org/blog/250901deep-learning-glossary/

深度学习笔记-1：多项式拟合、概率论与信息论基础

MuxiaoWF — Mon, 01 Sep 2025 00:00:00 GMT

系列第 1/8 篇 → 下一篇 | 术语表

这个系列一共8篇，建议按顺序看，但如果时间有限：

想了解基础概念：读第1-3篇

想理解神经网络怎么训练：读第4篇

想了解主流架构：读第5篇-第6篇

想理解生成模型：读第7篇-第8篇

遇到不认识的术语？查术语表

前置知识：“理论上”高中数学就够了，最好有高数的基础。如果你知道什么是函数、什么是导数，就能读下去。 本篇目标：读完你会理解——什么是过拟合、正则化怎么用、概率论和信息论最核心的概念。

参考书：《深度学习：基础与概念》(2025) - Christopher M. Bishop、Hugh Bishop 著

Chapter 1 深度学习前言：从画线到神经网络

用一条线穿过一堆点

想象你有一堆散点图（比如房屋面积和价格的关系），你想画一条线来描述这个规律。这条线画得好不好，怎么衡量？

误差函数（error function） 就是干这个的：把每个数据点 $x_n$ 的实际值 $t_n$ 和你画的线的预测值 $y(x_n,w)$ 之间的差距（误差）平方一下，全部加起来，再除以2——这样就得到了一个”画得好不好”的分数，分数越小说明画得越好。

用人话说就是：误差函数 = 每个点的”偏离程度”的平方和的一半。

E(w) = \frac{1}{2}\sum_{n=1}^{N} (y(x_n,w) - t_n)^2

其中 $(y(x_n,w) - t_n)^2$ 是第 $n$ 个点的预测误差。

其中多项式函数（就是你画的那条线）为：

P(x) = w_nx^n + w_{n-1}x^{n-1} + \cdots + w_1x + w_0=\sum_{j=0}^{n} w_j x^j

误差函数永远≥0（因为是平方和），我们的目标就是找到让这个函数最小的那组参数 $w$ ，记为 $w^*$ 。怎么找？对 $E(w)$ 求导，令导数为0，解出来的 $w$ 就是 $w^*$ 。

绿色为误差，红色为预测函数，蓝色为真实值

模型复杂度：太简单和太复杂都不行

选几阶多项式（模型复杂度）是个大学问：

欠拟合（underfitting）：模型太简单，连数据的基本规律都没学到（比如用一条直线去拟合抛物线形状的数据）
过拟合（overfitting）：模型太复杂，把数据里的噪声（随机波动）也当规律学进去了，导致在新数据上表现很差（比如用10阶多项式去拟合本来是2阶的数据，曲线会剧烈震荡）

怎么判断是否过拟合？把数据分成训练集（用来拟合模型）和测试集（用来检验模型），用均方根误差（root mean square error） 来评估：

E_{RMS} = \sqrt{\frac{1}{N}\sum_{n=1}^{N} (y(x_n,w^*) - t_n)^2}

这个公式做了两件事：除以 $N$ 让不同大小的数据集可以公平比较，开平方让误差单位和原始数据一致（比如房价用”元”而不是”元²”）。

阶数越大模型越复杂，越容易过拟合；越小越容易欠拟合

直觉上很好理解：阶数越高，曲线越”灵活”，就越容易被数据里的随机噪声带跑偏，系数幅度也会变得很大。同时，数据量越大，越能支撑复杂的模型——这就像考试题目越多，越不容易靠运气蒙对。

简单来说：模型复杂度要和数据量匹配。数据少就用简单模型，数据多才能用复杂模型。

正则化：给模型加个”紧箍咒”

你可能会问：既然过拟合是因为参数 $w$ 太大导致模型太复杂，那能不能直接限制 $w$ 的大小？

没错！这就是正则化（regularization） 的思路。做法很简单：在原来的误差函数后面加一个惩罚项，谁的 $w$ 大就罚谁：

E(w) = \frac{1}{2}\sum_{n=1}^{N} (y(x_n,w) - t_n)^2 + \frac{\lambda}{2}\sum_{j=0}^{n} w_j^2

这个惩罚项也叫权重衰减（weight decay），因为它会让参数 $w$ 不断”缩小”。从概率论的角度看（后面第2章会详细讲），这相当于给参数 $w$ 施加了一个均值为0的高斯先验——意思是我们事先假设参数应该比较小。

关键在于 $\lambda$ （lambda，正则化系数）的大小：

$\lambda$ 越大 → 惩罚越重 → $w$ 越小 → 模型越简单 → 越容易欠拟合
$\lambda$ 越小 → 惩罚越轻 → $w$ 越大 → 模型越复杂 → 越容易过拟合

怎么选 $\lambda$ ？用验证集试试不同的 $\lambda$ 值，看哪个 $E_{RMS}$ 最小就行了。

验证集的均方根误差与λ

简单来说：正则化就像给模型加了个紧箍咒——参数想变大？先问问 $\lambda$ 答不答应。

交叉验证：怎么公平地评估模型？

上面我们说用验证集来选 $\lambda$ ，但问题是：验证集怎么划分？划太大训练数据不够，划太小评估不准。

S折交叉验证（S-fold cross-validation） 是一个巧妙的解决方案：

把数据随机分成 $K$ 份（比如K=4）
第1轮：用第2、3、4份训练，第1份验证；第2轮：用第1、3、4份训练，第2份验证…依此类推
跑完 $K$ 轮后，对所有验证误差取平均

K=4的S折，红色为验证集

这样每份数据都当过一次验证集，评估结果更可靠。代价是训练次数多了 $K$ 倍。

特殊情况：当 $K=N$ （数据集大小）时，每次只留1个样本验证，叫做留一法（leave-one-out）。

S折交叉验证常用于选择神经网络的超参数（hyperparameter，就是训练前需要人工设定的参数，比如隐藏层节点数、学习率），避免对某一种划分方式的依赖。

习题1

题目背景：假设你有一个包含1000个样例的数据集，正负各半。你想用70%做训练、30%做测试来评估模型。问题是：你能有多少种不同的划分方式？

500*70%=350，即在正例里抽取 $C_{500}^{350}$ 并在负例里抽取 $C_{500}^{350}$ ，累计抽取 $C_{500}^{350}*C_{500}^{350}$

习题2

题目背景：一个非常”偷懒”的分类器——它只看训练集里哪个多就预测哪个，一样多就瞎猜。用这种极端分类器来理解交叉验证和留一法的区别。

假设学习算法所产生的模型按照类别出现的概率进行预测，将新样例预测为训练样例数较多的类别（训练样例数相同时进行随机猜测），考虑在以下两种情况下交叉验证法和留一法的差异。

假设数据集包含100个样例，其中正负例各一半。

10折交叉验证：将数据集平均分成大小相同的10个子集，将其中9个作为训练集，1个作为测试集并最终取平均。由于题目已知将新样例预测为训练样例数较多的类别模型且训练样例数相同时进行随机猜测，此时每次训练正负样例数均相同，因此错误率期望为50%。

留一法：若留出样本为正例，训练集中则有50个负例和49个正例，模型会预测为负例；反之留出样本为负例，模型预测为正例，错误率期望为100%。

假设数据集包含100个样例，其中正例51个，负例49个。

10折交叉验证：此时10个子集分布不均，即分为9个5正例5负例子集和1个6正例4负例子集。当训练集中有45个正例和45个负例时，此时进行随机猜测，错误率期望为 $50\%*\frac{9}{10} = 45\%$ ；当训练集中有46个正例和44个负例时，此时预测为正例，测试集有5正例5负例，错误率期望为 $50\%*\frac{1}{10} = 5\%$ ；综上，错误率期望为 $45\% + 5\% = 50\%$

留一法：若留出样本为正例，训练集中则有49个负例和50个正例，模型会预测为正例；反之留出样本为负例，模型预测为正例，错误率期望为 $0\%*\frac{51}{100} + 100\%*\frac{49}{100} = 49\%$ 。

神经网络：从一个”开关”开始

当数据关系非常复杂（高度非线性）时，多项式拟合需要很高的阶数，容易过拟合。有没有更好的办法？

神经网络（neural network） 就是答案。它的灵感来自人脑：神经元通过突触连接，接收信号、处理、输出。我们从最简单的”神经元”开始：

一个神经元做三件事：

接收输入：把所有输入 $x_1, x_2, \cdots, x_n$ 各自乘上一个权重 $w_1, w_2, \cdots, w_n$ ，加起来——得到预激活（pre-activation，就是加权求和但还没过激活函数的值）
激活：把预激活的值通过一个激活函数（activation function） 进行非线性变换
输出：得到这个神经元的结果

a = w_1x_1 + w_2x_2 + \cdots + w_nx_n \quad \text{（预激活：加权求和）}

y = f(a) \quad \text{（激活：过激活函数得到输出）}

常用的激活函数有sigmoid（S形曲线，把任意值压缩到0~~1之间）、tanh（类似sigmoid但输出范围是-1~~1）、ReLU（负数变0，正数不变，现代深度网络的首选）。

类比：树突接收输入信号 → 细胞体处理（激活） → 轴突输出结果。

最简单的神经网络就是感知机（perceptron）——只有一个神经元，激活函数是一个”开关”：

f(a) = \begin{cases} 1 & \text{if } a \ge 0 \\ 0 & \text{otherwise} \end{cases}

现代的多层感知机（multi-layer perceptron, MLP） 就是把很多这样的”开关”叠成多层，每一层的输出作为下一层的输入，层层传递，最后得到结果。层数越多，能学到的模式越复杂——这就是”深度学习”中”深度”的由来。

第1章小结

一句话版本：

误差函数：衡量模型画的线离数据点有多远，越小越好
过拟合：模型太复杂，把噪声当规律；欠拟合：模型太简单，连规律都没学到
正则化：给参数加惩罚项，防止模型太复杂
交叉验证：把数据分成多份轮流训练和验证，公平评估模型
神经网络：一堆简单的”开关”叠成多层，能学到非常复杂的模式

知识地图：

1
误差函数 → 过拟合/欠拟合 → 正则化 + 交叉验证
2
                              ↓
3
                         多项式拟合的局限 → 神经网络（MLP）

下一章我们会学习概率论——它是理解”为什么误差函数长这样”以及”模型怎么做出预测”的数学基础。

Chapter 2 概率：不确定性下的推理

为什么需要概率？因为现实世界充满了不确定性。

不确定性分两种：

偶然不确定性（aleatoric uncertainty）：数据本身就有噪声，比如测量仪器的误差、人体身高的自然波动——这是无法消除的
认知不确定性（epistemic uncertainty）：因为我们收集的数据不够多，对规律的认识不完整——数据越多，这种不确定性越小

概率论就是处理不确定性的数学语言。深度学习的很多核心概念（最大似然估计、交叉熵、KL散度）都建立在概率论之上。

前置知识：知道什么是”概率”就够了。

两大学派：概率到底是什么？

从一个硬币说起：正面朝上的概率是0.5——但这句话到底是什么意思？

频率学派（frequentist） 认为：概率就是”反复做很多次实验，某件事发生的频率”。你投1000次硬币，大概500次正面，所以概率是0.5。参数（比如硬币的重量分布）是固定但未知的，我们用数据来估计它。

代表方法：最大似然估计（MLE）、置信区间

贝叶斯学派（Bayesian） 认为：概率是”我们对某件事发生的相信程度”。你还没投硬币，但根据经验觉得大概各半，这就是先验信念；投了几次之后，根据结果更新这个信念。

关键公式：贝叶斯定理（下面会讲）

两种观点各有道理，在深度学习中都有应用。频率学派的方法更常见（比如最大似然估计），但贝叶斯思想在正则化和不确定性估计中也很重要。

概率基础：三条铁律

概率法则只有三条，记住它们就够了：

加和法则（sum rule）：想知道 $X=x_i$ 的概率，把所有可能的 $Y$ 值下 $X=x_i$ 的概率加起来：

P(X = x_i) = \sum_{y_j \in Y} P(X = x_i, Y = y_j)

乘积法则（product rule）：两个事件同时发生的概率 = 第一个发生的概率 × 第一个发生的条件下第二个发生的概率：

P(X = x_i, Y = y_j) = P(X = x_i)P(Y = y_j | X = x_i)

贝叶斯定理（Bayes’ theorem）：这是最重要的一个——它告诉我们怎么用”结果”反推”原因”：

P(Y | X) = \frac{P(X | Y)P(Y)}{P(X)}

用人话说就是：后验概率 = (似然 × 先验) / 证据

先验概率（prior） $P(Y)$ ：观测 $X$ 之前，我们对 $Y$ 的信念
后验概率（posterior） $P(Y|X)$ ：观测 $X$ 之后，更新对 $Y$ 的信念
似然（likelihood） $P(X|Y)$ ：如果 $Y$ 是真的，观测到 $X$ 的可能性
证据（evidence） $P(X)$ ：归一化常数，确保概率总和为1

举个例子：你看到地上是湿的（ $X$ ），想判断是不是下雨了（ $Y$ ）。先验 $P(Y)$ ：根据天气预报，下雨概率30%。似然 $P(X|Y)$ ：如果下雨了，地面湿的概率90%。似然 $P(X|\neg Y)$ ：如果没下雨，地面湿的概率10%（可能是洒水车）。后验 $P(Y|X)$ ：看到地面湿了之后，实际下雨的概率是多少？用贝叶斯定理算一下就知道。

独立（independence）：如果两个变量 $X$ 和 $Y$ 互不影响， $P(X, Y) = P(X)P(Y)$ 。

概率密度：连续变量的概率

对于离散变量（比如骰子点数），每个值都有一个确定的概率。但对于连续变量（比如身高、温度），取某个精确值的概率是0——你能恰好是170.000000…厘米吗？不可能。

所以引入概率密度函数（probability density function, PDF） $p(x)$ ：它表示 $x$ 落在某个小区间 $(x, x+\delta x)$ 内的概率大约是 $p(x)\delta x$ 。

$x$ 落在区间 $(a, b)$ 的概率就是密度曲线在这个区间下的面积：

p(x \in (a, b)) = \int_a^b p(x) dx

概率密度函数必须满足两个条件：

非负性： $p(x) \geq 0$ （概率不能是负数）
归一化： $\int_{-\infty}^{\infty} p(x) dx = 1$ （总概率必须是1）

累积分布函数（cumulative distribution function, CDF） $P(z) = \int_{-\infty}^z p(x) dx$ ，表示” $x$ 小于等于 $z$ 的概率”。它的导数就是概率密度： $P'(x) = p(x)$ 。

上面的加和法则和乘积法则对连续变量同样适用，只是把求和换成积分：

和规则： $p(\mathbf{x}) = \int p(\mathbf{x}, \mathbf{y}) d\mathbf{y}$ （对不关心的变量”积分掉”）
积规则： $p(\mathbf{x}, \mathbf{y}) = p(\mathbf{y}|\mathbf{x})p(\mathbf{x})$

贝叶斯定理同样：

p(\mathbf{y}|\mathbf{x}) = \frac{p(\mathbf{x}|\mathbf{y})p(\mathbf{y})}{p(\mathbf{x})}, \quad \text{其中} \quad p(\mathbf{x}) = \int p(\mathbf{x}|\mathbf{y})p(\mathbf{y}) d\mathbf{y}

上面的规则同样适用（ $\mathbf{x}, \mathbf{y}$ 为两个实数变量，多元多维）：

和规则 - 对部分变量感兴趣时，可以通过对其他变量”积分掉”来获得感兴趣变量的分布

p(\mathbf{x}) = \int p(\mathbf{x}, \mathbf{y}) d\mathbf{y} \quad \text{将y积分掉}

积规则 - 需要考虑变量间的依赖关系时，可以将联合分布分解为条件分布和边缘分布的乘积

p(\mathbf{x}, \mathbf{y}) = p(\mathbf{y}|\mathbf{x})p(\mathbf{x})

贝叶斯定理

p(\mathbf{y}|\mathbf{x}) = \frac{p(\mathbf{x}|\mathbf{y})p(\mathbf{y})}{p(\mathbf{x})}

分母（边缘概率）同样可以写成：

p(\mathbf{x}) = \int p(\mathbf{x}|\mathbf{y})p(\mathbf{y}) d\mathbf{y}

常见概率分布

在进入深度学习之前，我们先认识几个最常用的概率分布（probability distribution）。你可以把它们想象成”乐高积木”——很多复杂的概率模型都是由这些基本分布拼装而成的。

均匀分布（uniform distribution）：最简单的一种——在有限区间 $(c, d)$ 内概率密度处处相等，就像把水均匀地倒在一个平底容器里：

p(x) = \frac{1}{d - c}, \quad x \in (c, d)

指数分布（exponential distribution）：概率密度从某个起点开始单调递减，常用来建模”等待时间”（比如等公交车要等多久）：

p(x|\lambda) = \lambda \exp(-\lambda x), \quad x > 0

其中 $\lambda$ （lambda）越大，下降得越快，说明”很快就能等到”的概率越高。

拉普拉斯分布（Laplace distribution）：长得像两个背靠背的指数分布，中心在 $\mu$ 处，有一个尖尖的顶。它比高斯分布更”尖”、尾巴更”厚”，对离群点更鲁棒：

p(x|\mu, \gamma) = \frac{1}{2\gamma} \exp\left(-\frac{|x - \mu|}{\gamma}\right)

红色为均匀分布，蓝色为指数分布，绿色为拉普拉斯分布

接下来两个分布比较特殊，它们不是普通的”曲线”，而是在概率论和统计中非常有用的工具：

狄拉克δ函数（Dirac delta function）：这不是普通函数，而是一种”广义函数”——你可以把它想象成一根无限细、无限高的”针”，扎在 $x = \mu$ 处，但这根针下面的面积刚好是1：

p(x|\mu) = \delta(x - \mu)

除 $x = \mu$ 外处处为零，但 $\int p(x|\mu) dx = 1$ 。它在物理和概率论中经常出现，用来表示”精确确定在某个位置”。

经验分布（empirical distribution）：给你一组真实数据 $D = \{x_1, \ldots, x_N\}$ ，经验分布就是用这组数据本身来”近似”真实分布——做法很简单，在每个数据点 $x_n$ 处扎一根δ函数的”针”，每根针的高度都是 $\frac{1}{N}$ ：

p(x|D) = \frac{1}{N} \sum_{n=1}^N \delta(x - x_n)

用人话说：你有10个观测数据，经验分布就是说”每个数据出现的概率都是1/10，其他地方概率为0”。它是最朴素的”用数据说话”的方式。

期望和方差

期望（expectation）

用人话说，期望就是”加权平均值”的理论版本。你平时算平均值是把所有数据加起来除以个数，期望则是每个值乘以它出现的概率再求和——考虑了”每个值有多可能出现”。

离散情况：每个值乘以对应概率，求和

E[f] = \sum_x p(x)f(x)

连续情况：把求和换成积分

E[f] = \int p(x)f(x) dx

有限样本：当你只有有限个数据点时，用经验分布来近似——就是前面说的”在每个数据点扎一根针”的做法。具体来说，用δ函数的性质（ $\int \delta(x - x_n) f(x) dx = f(x_n)$ ）可以化简为：

E[f] \approx \frac{1}{N} \sum_{n=1}^N f(x_n)

简单来说：样本平均值是期望的近似。数据越多，近似越准。这正是第十四章-蒙特卡洛近似的核心思想。

推导细节：从经验分布到样本均值

E[f] = \int_{-\infty}^{\infty} \left[\frac{1}{N} \sum_{n=1}^N \delta(x - x_n)\right] f(x) dx = \frac{1}{N} \sum_{n=1}^N \int_{-\infty}^{\infty} \delta(x - x_n) f(x) dx

令 $y = x - x_n$ ，则 $x = y + x_n$ ， $dx = dy$ ：

\int_{-\infty}^{\infty} \delta(x - x_n) f(x) dx = \int_{-\infty}^{\infty} \delta(y) f(y + x_n) dy = f(x_n)

因此 $E[f] = \frac{1}{N} \sum_{n=1}^N f(x_n)$ 。

条件期望（conditional expectation）：已知某个变量 $y$ 的值之后， $f(x)$ 的期望——结果是 $y$ 的函数：

E[f(x)|y] = \int p(x|y)f(x) dx

方差（variance）

方差衡量的是”数据围绕期望的分散程度”——简单来说就是”波动有多大”。方差越大，数据越分散；方差越小，数据越集中在均值附近。

\text{var}[f] = E[(f(x) - E[f(x)])^2] = E[f(x)^2] - E[f(x)]^2

其中 $E[f(x)^2]$ 是”平方的期望”， $E[f(x)]^2$ 是”期望的平方”——方差就是这两者的差。

变量 $x$ 自身的方差就是 $f(x) = x$ 的特殊情况：

\text{var}[x] = E[x^2] - E[x]^2

协方差（covariance）

协方差衡量两个变量”一起变化的趋势”。如果 $x$ 增大时 $y$ 也倾向于增大，协方差为正；一个增大另一个减小，协方差为负；互不影响则为0。

\text{cov}[x, y] = E[(x - E[x])(y - E[y])] = E[xy] - E[x]E[y]

如果 $x$ 和 $y$ 独立，则 $\text{cov}[x, y] = 0$ （注意反过来不成立——协方差为0不代表独立，可能有非线性关系）。

向量的协方差：对于向量 $\mathbf{x}$ 和 $\mathbf{y}$ ，协方差是一个矩阵：

\text{cov}[\mathbf{x}, \mathbf{y}] = E[\mathbf{x}\mathbf{y}^T] - E[\mathbf{x}]E[\mathbf{y}]^T, \quad \text{cov}[\mathbf{x}] \equiv \text{cov}[\mathbf{x}, \mathbf{x}]

向量 $\mathbf{x}$ 自身的协方差矩阵描述了各分量之间的相关性——对角线上是方差，非对角线上是协方差。

高斯分布（正态分布）

高斯分布（Gaussian distribution），又叫正态分布（normal distribution），是概率论中最重要的分布，没有之一。它的形状是一条对称的钟形曲线（bell curve）——中间高、两边低，左右对称。

高斯分布 → 最大似然估计 → 线性回归的损失函数推导 → 噪声建模的意义

这条线索贯穿了接下来的几个小节，读的时候可以带着这个问题：为什么高斯分布这么重要？

单变量高斯分布

\mathcal{N}(x|\mu, \sigma^2) = \frac{1}{\sqrt{2\pi\sigma^2}} \exp\left(-\frac{(x - \mu)^2}{2\sigma^2}\right)

看起来公式挺吓人，但其实只有两个参数在控制一切：

$\mu$ （mu，均值）：决定钟形曲线的中心位置——曲线最高点在哪里
$\sigma^2$ （sigma squared，方差）：决定钟形曲线的宽度—— $\sigma$ 越大，曲线越”胖”、越”矮”； $\sigma$ 越小，曲线越”瘦”、越”高”
$\sigma$ （标准差）：方差的平方根，和方差描述同一件事，只是单位和原始数据一致
$\beta = 1/\sigma^2$ （精度 precision）：方差的倒数，精度越大说明分布越集中

当然，作为概率密度函数，它必须满足：

\mathcal{N}(x|\mu, \sigma^2) > 0 \quad \text{且} \quad \int_{-\infty}^{\infty} \mathcal{N}(x|\mu, \sigma^2) dx = 1

高斯分布的性质

期望（一阶矩）： $E[x] = \mu$ ——分布的”重心”就在均值处。有关矩的概念可以看第3章-矩
二阶矩： $E[x^2] = \mu^2 + \sigma^2$
方差： $\text{var}[x] = E[x^2] - E[x]^2 = \sigma^2$
众数（mode，概率密度最大值的位置）：对高斯分布来说，众数和均值 $\mu$ 重合——最高点就在正中间

线性回归的概率视角

还记得第1章讲的线性回归和误差函数吗？现在我们可以用概率的语言重新理解它。

把回归问题（regression problem）建模为条件概率：目标值 $t$ 是一个随机变量，它服从以预测值 $y(x, \mathbf{w})$ 为中心的高斯分布：

p(t|x, \mathbf{w}, \sigma^2) = \mathcal{N}(t|y(x, \mathbf{w}), \sigma^2)

其中 $y(x, \mathbf{w})$ 是模型的预测， $\sigma^2$ 是噪声方差。

想象你在预测房价：输入 $x$ 为房子面积，模型预测 $y(x, \mathbf{w})$ 为预测价格。实际价格 $t$ 不会刚好等于预测价格——它会在预测价格附近随机波动（因为还有学区、装修等因素没考虑进去）。

概率观点说：这个波动服从高斯分布。也就是说，房价 $t$ 服从以预测值 $y(x, \mathbf{w})$ 为均值的高斯分布。好处是什么？预测时你可以输出一个区间（比如 $y \pm 2\sigma$ ），而不是一个孤零零的数字——这样就能量化不确定性。

似然函数

什么是似然？

想象你玩一个”猜参数”游戏：我给你一组数据（比如10个人的身高），告诉你这些数据来自一个高斯分布，但不告诉你均值和方差是多少。你的任务是：猜一组参数，使得”这组数据出现的概率”最大。

这个”数据出现的概率”就是似然函数（likelihood function）。给定参数 $\mu$ 和 $\sigma^2$ ，观察到数据集 $\mathbf{x} = (x_1, \ldots, x_N)$ 的似然是：

p(\mathbf{x}|\mu, \sigma^2) = \prod_{n=1}^N \mathcal{N}(x_n|\mu, \sigma^2)

你可能会问：为什么要连乘？因为我们假设数据是独立同分布（independent and identically distributed, i.i.d.）的——每个数据点都是独立从同一个分布中抽取的，所以联合概率就是各概率的乘积。

对数似然

连乘很麻烦（数值上容易溢出），所以通常取对数，把连乘变成连加：

\ln p(\mathbf{x}|\mu, \sigma^2) = -\frac{1}{2\sigma^2} \sum_{n=1}^N (x_n - \mu)^2 - \frac{N}{2} \ln \sigma^2 - \frac{N}{2} \ln(2\pi)

最大似然估计（Maximum Likelihood, ML）

最大似然估计（maximum likelihood estimation, MLE） 就是”猜参数”游戏的答案——找到让似然函数最大的那组参数。做法是：对似然函数（或对数似然）求导，令导数为0，解出参数。

对于高斯分布，结果出奇地简洁：

均值 $\mu$ 的最大似然解：就是样本均值（sample mean） $\mu_{ML} = \frac{1}{N} \sum_{n=1}^N x_n$
方差 $\sigma^2$ 的最大似然解：就是样本方差（sample variance） $\sigma^2_{ML} = \frac{1}{N} \sum_{n=1}^N (x_n - \mu_{ML})^2$

用人话说：你想知道一群人的平均身高和身高的波动范围？把他们的身高取平均就是 $\mu_{ML}$ ，算一下每个人和均值的差距的平方的平均值就是 $\sigma^2_{ML}$ 。

最大似然估计的偏差

这里有一个微妙但重要的问题：最大似然估计的方差是有偏的（biased）。

对于高斯分布：

$E[\mu_{ML}] = \mu$ （均值估计无偏——正好）
$E[\sigma^2_{ML}] = \frac{N-1}{N} \sigma^2$ （方差估计有偏——系统性地低估了真实方差）

为什么方差会低估？想象你在预测身高：

如果你知道真实的平均身高，你可以直接用这个值计算方差

但你不知道——你只能用这组数据算出的样本均值 $\mu_{ML}$ 来代替

样本均值是从同一组数据算出来的，它天然比真实均值更”贴近”这组数据

所以算出来的方差就会偏小——这就像”自己给自己打分”，总比别人打的高一点

修正方法：用 $N-1$ 代替 $N$ 做分母，得到无偏方差估计（unbiased variance estimator）：

\tilde{\sigma}^2 = \frac{1}{N-1} \sum_{n=1}^N (x_n - \mu_{ML})^2

简单来说：随着数据量 $N$ 增大， $\frac{N-1}{N}$ 越来越接近1，偏差越来越小。但在复杂模型（如神经网络）中，数据相对于参数量往往不够多，最大似然的偏差问题（和过拟合密切相关）会更严重。

最大似然估计 = 最小化平方和误差

还记得第1章的误差函数吗？现在我们可以从概率的角度理解它了。

当我们用高斯分布建模回归问题时，最大化似然函数：

\prod_{n=1}^N \mathcal{N}(t_n|y(x_n, \mathbf{w}), \sigma^2)

取对数后得到对数似然函数。其中 $-\frac{N}{2}\ln(2\pi\sigma^2)$ 这项与 $\mathbf{w}$ 无关，所以只需要最大化：

-\frac{1}{2\sigma^2} \sum_{n=1}^N (y(x_n, \mathbf{w}) - t_n)^2

因为 $\sigma^2 > 0$ 是常数，这等价于最小化平方和误差函数：

\frac{1}{2} \sum_{n=1}^N (y(x_n, \mathbf{w}) - t_n)^2

这就是为什么平方和误差是回归问题的默认损失函数——它不是凭空设计的，而是假设噪声服从高斯分布时，最大似然估计的自然结果。

换句话说：最小二乘法 = 高斯噪声假设下的最大似然估计。

预测分布

有了最大似然估计的参数，我们就可以写出完整的预测分布。噪声方差的最大似然估计为：

\sigma^2_{ML} = \frac{1}{N} \sum_{n=1}^N (y(x_n, \mathbf{w}_{ML}) - t_n)^2

预测分布就是：

p(t|x, \mathbf{w}_{ML}, \sigma^2_{ML}) = \mathcal{N}(t|y(x, \mathbf{w}_{ML}), \sigma^2_{ML})

预测身高的例子：

输入：年龄 $x = 10$ 岁

模型预测： $y(10, \mathbf{w}) = 140$ cm

最大似然估计的噪声方差： $\sigma^2 = 25$ （标准差 $\sigma = 5$ cm）

实际身高 $t$ 的分布： $p(t|x=10) = \mathcal{N}(t|140, 25)$

所以我们可以预期实际身高大概在 130~150 cm 之间（均值 $\pm 2$ 个标准差，覆盖约95%的概率）

变量变换

你可能会问：概率密度在变量变换下会怎么变化？这不是简单地”把 $x$ 换成 $y$ “就完事了——概率密度的变换方式和普通函数不一样。

先从直觉开始：橡皮筋拉伸

想象你在一根橡皮筋上均匀地涂了墨水（概率密度均匀分布）。现在你把橡皮筋拉伸成原来的2倍长——墨水被”稀释”了，密度变成了原来的一半。但总的墨水量（概率）没有变。

简单例子：线性变换 $x = 2y$ 在 $y$ 空间中，区间 $[0, 1]$ 的长度是1；在 $x$ 空间中变成 $[0, 2]$ ，长度是2。如果 $p_y(y) = 1$ （在 $[0,1]$ 区间内），那么 $p_x(x)$ 在对应区间应该是 $1/2$ ——这样总概率才守恒： $\int_0^1 p_y(y) dy = \int_0^2 p_x(x) dx = 1$

非线性变量变换

对于线性变换，缩放因子是常数。但对于非线性变换，“拉伸比例”在每个位置都不一样——这就像橡皮筋不同位置的拉伸程度不同。

考虑一个小区间 $[y, y+dy]$ ，在 $y$ 空间中的概率是 $p_y(y) dy$ （还记得概率密度函数吗？）。

经过变换 $x = g(y)$ 后，这个区间变成 $[x, x+dx]$ ，其中 $dx = g'(y) dy$ 。为了保持概率守恒（变换前后的概率必须相等）：

p_y(y) dy = p_x(x) dx = p_x(g(y)) \cdot g'(y) dy

因此：

p_y(y) = p_x(g(y)) \cdot \left|\frac{dg}{dy}\right|

取绝对值是因为概率密度必须非负。这里的 $\left|\frac{dg}{dy}\right|$ 就是雅可比因子（Jacobian factor）——一维时就是导数的绝对值，表示变换前后区间长度的缩放比例。

单变量变换公式

设 $x = g(y)$ ，则新变量 $y$ 的概率密度为：

p_y(y) = p_x(x) \cdot \left|\frac{dx}{dy}\right| = p_x(g(y)) \cdot \left|\frac{dg}{dy}\right|

模式位置会变！

模式（mode）就是概率密度函数达到最大值的点（对高斯分布来说就是均值）。这里有一个容易犯的错误：

如果我们简单地认为 $p_y(y) = p_x(g(y))$ （忽略雅可比因子），会以为模式只是做了一个坐标变换—— $p_x$ 的模式在 $\hat{x}$ ，变换后 $p_y$ 的模式就在满足 $\hat{x} = g(\hat{y})$ 的 $\hat{y}$ 处。

但这是错的！ 因为公式里多了一个 $\left|\frac{dg}{dy}\right|$ 项，它的导数会引入额外项，导致模式位置发生偏移。

举个例子：假设 $p_x(x) = \mathcal{N}(x|1, 0.5^2)$ （模式在 $x = 1$ ），做非线性变换 $x = g(y) = y^3$ ：

错误的期望：忽略雅可比，认为模式在 $y = 1$ （因为 $1^3 = 1$ ）
正确的变换： $p_y(y) = p_x(y^3) \cdot \left|\frac{d(y^3)}{dy}\right| = p_x(y^3) \cdot |3y^2|$ 由于额外的 $3y^2$ 项， $p_y(y)$ 的最大值位置会发生偏移，不再满足 $\hat{x} = g(\hat{y})$ 。

这个结论可以通过采样来验证：对 $x$ 采样后变换到 $y$ ， $y$ 的直方图与 $p_y(y)$ 匹配，而非与 $p_x(g(y))$ 匹配。

结果应当为红色曲线，而不是绿色曲线，极大值（模式）是不匹配的

注意：线性变换下，雅可比因子是常数，这个问题就消失了——模式位置的变换符合预期。

多变量分布的变换

设 $\mathbf{x} = \mathbf{g}(\mathbf{y})$ （ $\mathbf{x}$ , $\mathbf{y}$ 均为 $D$ 维向量），变换公式为：

p_{\mathbf{y}}(\mathbf{y}) = p_{\mathbf{x}}(\mathbf{x}) \cdot |\det \mathbf{J}|

其中 $\mathbf{J}$ 是雅可比矩阵（Jacobian matrix），元素为 $J_{ij} = \frac{\partial g_i}{\partial y_j}$ 。

$|\det \mathbf{J}|$ 是雅可比矩阵的行列式的绝对值——你可以把它理解为”橡皮筋拉伸”的多维版本：原来在 $(y_1, y_2)$ 空间中有一个小方块，经过变换后在 $(x_1, x_2)$ 空间中变成了一个不规则的四边形， $|\det \mathbf{J}|$ 就是面积（或体积）的缩放因子。

变量变换在深度学习中非常重要——标准化流（normalizing flow）模型的核心思想就是通过一系列可逆变换，把简单的分布（如高斯分布）逐步变换为复杂的分布。每一次变换都需要乘上雅可比因子。

熵

信息量：一个”惊讶度量表”

想象你是一个新闻编辑。下面两条新闻，哪条更”有料”？

“明天太阳从东边升起”——概率几乎100%，毫无惊喜
“明天太阳从西边升起”——概率几乎0%，超级震惊

直觉告诉我们：越不可能发生的事情，发生时带来的信息量越大。这就是信息量（information content） 的核心思想。

信息量函数 $h(x)$ 应该满足两个条件：

概率越低，信息量越大；概率为1的事件，信息量为0
两个独立事件同时发生的信息量 = 各自信息量之和（可加性）

满足这两个条件的函数就是概率的对数（负号确保非负）：

h(x) = -\log_2 p(x)

底数为2时，单位是比特（bits）。

熵：平均信息量

熵（entropy） $H[x]$ 就是信息量的期望（平均值）——衡量一个随机变量整体上有多”不确定”或多”混乱”：

H[x] = -\sum_x p(x) \log_2 p(x)

当 $p(x) = 0$ 时，定义 $p(x) \ln p(x) = 0$ （因为 $\lim_{x \to 0} x \ln x = 0$ ）。

例子：

均匀分布：8个等概率状态，每个概率 $1/8$ 。熵 $H[x] = -8 \times \frac{1}{8} \log_2 \frac{1}{8} = 3$ 比特。

因为每个状态都同样可能，你完全猜不到下一个会是什么——不确定性最大。
非均匀分布：状态 $\{a, b, c, d, e, f, g, h\}$ 的概率为 $\{\frac{1}{2}, \frac{1}{4}, \frac{1}{8}, \frac{1}{16}, \frac{1}{64}, \frac{1}{64}, \frac{1}{64}, \frac{1}{64}\}$ 。熵 $H[x] = 2$ 比特。

因为 $a$ 出现的概率很高（一半），你比较容易猜对——不确定性更小。

信源编码定理（source coding theorem）：熵是无损压缩中平均码长的下限。在第二个例子中，可以通过为高频事件分配短码（比如 a 用 0，b 用 10）来实现平均码长等于熵（2比特）。

后续我们使用自然对数（底数为 $e$ ）来定义熵，单位改为纳特（nats）。这是深度学习中的惯例： $H[x] = -\sum_x p(x) \ln p(x)$

微分熵：连续变量的熵

把熵的概念扩展到连续变量——微分熵（differential entropy）。

思路：把连续变量 $x$ 按宽度 $\Delta$ 分箱（binning），每个箱内用一个值 $x_i$ 代表，概率约为 $p(x_i)\Delta$ 。先算离散熵，再取 $\Delta \to 0$ 的极限：

H_\Delta = -\sum_i p(x_i)\Delta \ln (p(x_i)\Delta) = -\sum_i p(x_i)\Delta \ln p(x_i) - \ln \Delta

忽略与 $p(x)$ 无关的 $-\ln \Delta$ ，取极限得到微分熵：

H[x] = -\int p(x) \ln p(x) dx

多变量情况同理：

H[\mathbf{x}] = -\int p(\mathbf{x}) \ln p(\mathbf{x}) d\mathbf{x}

注意：微分熵和离散熵不同，它可以是负数！这是因为连续变量的”分箱”过程引入了 $-\ln \Delta$ 项，当分布非常集中时（方差很小），微分熵可以小于0。

最大熵分布

离散情况：在所有可能的状态上，熵最大的分布是均匀分布 $p(x_i) = 1/M$ ，此时 $H = \ln M$ 。直觉很好理解——均匀分布意味着”最不确定”，所以熵最大。

连续情况（有约束）：如果没有约束，连续分布的熵可以无限大（想象一个无限宽的均匀分布）。所以通常需要加上约束：

$\int p(x) dx = 1$ （归一化）
$\int x p(x) dx = \mu$ （已知均值）
$\int (x - \mu)^2 p(x) dx = \sigma^2$ （已知方差）

在给定均值 $\mu$ 和方差 $\sigma^2$ 的约束下，高斯分布是使微分熵最大的分布。

推导思路（使用拉格朗日乘子法 + 变分法）

在三个约束条件下最大化 $H[x] = -\int p(x) \ln p(x) dx$ 。构造拉格朗日函数，对 $p(x)$ 求变分导数并令其为零，可以得到 $p(x)$ 必须是 $x$ 的二次函数的指数形式——这正是高斯分布的形式。具体推导需要用到变分法（calculus of variations），这超出了本章范围。

高斯分布的微分熵

高斯分布的微分熵有一个漂亮的闭式解：

H[x] = \frac{1}{2} \{1 + \ln(2\pi\sigma^2)\}

熵随方差 $\sigma^2$ 增大而增大——分布越”胖”（方差越大），不确定性越大，熵越高。当 $\sigma^2 < 1/(2\pi e)$ 时，微分熵为负——这在离散熵中是不可能的。

KL散度

两个分布有多”不同”？

想象你有两份天气预报：一份是真实天气数据 $p(x)$ ，另一份是你的模型预测 $q(x)$ 。你想知道：你的预测和真实情况差多少？

Kullback-Leibler 散度（KL divergence），也叫相对熵（relative entropy），就是衡量两个概率分布之间”距离”的指标。用人话说：如果你用分布 $q(x)$ 来代替真实分布 $p(x)$ 做编码，平均需要多花多少信息量。

\mathrm{KL}(p \| q) = -\int p(x) \ln q(x) dx - \left( -\int p(x) \ln p(x) dx \right) = -\int p(x) \ln \left\{ \frac{q(x)}{p(x)} \right\} dx

第一项是”用 $q$ 编码的平均信息量”，第二项是”用 $p$ 编码的平均信息量（即熵）“——KL散度就是两者的差。

KL散度的两条重要性质

非负性： $\mathrm{KL}(p \| q) \geq 0$ ，当且仅当 $p(x) = q(x)$ 时等号成立。这很好理解——如果两个分布完全一样，“差异”就是0。
不对称性： $\mathrm{KL}(p \| q) \neq \mathrm{KL}(q \| p)$ 。从 $p$ 到 $q$ 的距离和从 $q$ 到 $p$ 的距离不一样！所以严格来说，KL散度不是真正的”距离”。

非负性证明（使用Jensen不等式）

凸函数（convex function）：函数 $f(x)$ 是凸的，如果其任意弦都在函数图像之上，即 $f(\lambda a + (1-\lambda)b) \leq \lambda f(a) + (1-\lambda)f(b)$ 。

Jensen不等式：对于凸函数 $f$ 和概率分布 $p(x)$ ： $f\left(\int x p(x) dx\right) \leq \int f(x) p(x) dx$ 用人话说就是：函数的期望值 ≥ 期望的函数值（对于凸函数）。

$-\ln x$ 是严格凸函数。令 $f(x) = -\ln x$ ，则：

\mathrm{KL}(p \| q) = -\int p(x) \ln \left\{ \frac{q(x)}{p(x)} \right\} dx \geq -\ln \left( \int q(x) dx \right) = -\ln(1) = 0

KL散度与最大似然估计的关系

最小化KL散度等价于最大化似然函数——这是连接概率论和机器学习的关键桥梁。

理论上：

\mathrm{KL}(p \| q) = -\int p(x) \ln q(x) dx + \int p(x) \ln p(x) dx

实际中，我们有来自真实分布 $p(x)$ 的样本 $\{x_1, x_2, \ldots, x_N\}$ ，可以近似为：

\mathrm{KL}(p \| q) \approx \frac{1}{N} \sum_{n=1}^N -\ln q(x_n|\theta) + \frac{1}{N} \sum_{n=1}^N \ln p(x_n)

第二项是常数（因为 $p(x)$ 是真实分布，不依赖于模型参数 $\theta$ ），所以最小化KL散度等价于最小化第一项——也就是最大化 $\sum_{n=1}^N \ln q(x_n|\theta)$ ——也就是最大化似然函数。

简单来说：训练模型时最小化KL散度，就是在做最大似然估计。这解释了为什么最大似然估计是如此自然和普遍的方法。

条件熵

条件熵（conditional entropy） $H[y|x]$ 衡量的是：已知变量 $x$ 之后，描述变量 $y$ 还需要多少平均信息量。

H[y|x] = -\iint p(y, x) \ln p(y|x) dy dx

天气预报的例子：

$x$ ：今天的天气（晴天/雨天）

$y$ ：明天的天气

$H[y]$ （无条件熵）：不看今天天气，预测明天天气有多不确定

$H[y|x]$ （条件熵）：看了今天天气之后，预测明天天气还有多不确定

显然 $H[y|x] \leq H[y]$ ，因为今天天气提供了有用信息——知道今天下雨会让你更容易预测明天也下雨。

条件熵、联合熵和边缘熵之间有一个优雅的链式法则（chain rule）：

H[x, y] = H[x] + H[y|x]

用人话说： $x$ 和 $y$ 的总信息量 = 描述 $x$ 的信息量 + 已知 $x$ 后描述 $y$ 的额外信息量。

互信息

互信息（mutual information） 衡量两个变量之间”共享了多少信息”——或者说，知道一个变量能帮你减少多少对另一个变量的不确定性。

从数学上看，互信息就是联合分布 $p(x,y)$ 与假设它们独立时的分布 $p(x)p(y)$ 之间的KL散度：

I[x, y] = \mathrm{KL}(p(x, y) \| p(x)p(y)) = -\iint p(x, y) \ln \left( \frac{p(x)p(y)}{p(x, y)} \right) dx dy

如果 $x$ 和 $y$ 独立： $p(x,y) = p(x)p(y)$ ，KL散度为0，互信息为0——知道 $x$ 对预测 $y$ 毫无帮助
如果 $x$ 和 $y$ 相关： $p(x,y) \neq p(x)p(y)$ ，互信息大于0——知道 $x$ 能帮你更好地预测 $y$

互信息与熵的关系非常直观：

I[x, y] = H[x] - H[x|y] = H[y] - H[y|x]

天气预报的例子（续）：

$H[x]$ ：预测今天天气的不确定性（比如2比特）

$H[x|y]$ ：已知明天天气后，预测今天天气的不确定性（比如0.5比特）

$I[x,y] = H[x] - H[x|y] = 2 - 0.5 = 1.5$ 比特

这1.5比特就是今天和明天天气共享的信息量——知道了明天天气，你就”免费”获得了1.5比特关于今天天气的信息。

从贝叶斯角度看， $p(x)$ 是先验分布（观察 $y$ 之前对 $x$ 的认识）， $p(x|y)$ 是后验分布（观察 $y$ 之后对 $x$ 的认识）。互信息 $I[x, y] = H[x] - H[x|y]$ 正好就是不确定性减少量——观察 $y$ 之后，你对 $x$ 的不确定性减少了多少。

互信息在深度学习中有很多应用，比如特征选择（选那些和目标变量互信息最大的特征）、信息瓶颈理论（information bottleneck）等。

第2章小结

一句话版本：

概率论基础：概率论只有三条规则——加和法则、乘积法则、贝叶斯定理。贝叶斯定理告诉我们怎么用观测结果更新信念
常见分布：均匀分布、指数分布、拉普拉斯分布是基本构件；狄拉克δ函数和经验分布是特殊工具
期望和方差：期望 = 平均值的理论版本，方差 = 波动有多大，协方差 = 两个变量一起变化的趋势
高斯分布：最重要的连续分布，钟形曲线，只由均值和方差两个参数决定。假设噪声服从高斯分布时，最大似然估计 = 最小二乘法
似然函数：给定参数时数据出现的概率。最大似然估计就是找”最可能产生这组数据”的参数
变量变换：概率密度变换时要乘雅可比因子（“橡皮筋拉伸”的缩放比例）
熵：不确定性的度量。“惊讶度量表”——概率越低的事件发生时信息量越大
KL散度：两个分布之间的”差异”。非负、不对称。最小化KL散度 = 最大化似然函数
条件熵和互信息：条件熵 = 已知一个变量后剩余的不确定性；互信息 = 两个变量共享的信息量

知识地图：

1
概率基础（加和/乘积/贝叶斯）
2
    ├── 常见分布（均匀/指数/拉普拉斯/狄拉克δ/经验分布）
3
    ├── 期望、方差、协方差
4
    ├── 高斯分布（钟形曲线）
5
    │     ├── 最大似然估计（MLE）
6
    │     │     ├── 均值 → 样本均值
7
    │     │     ├── 方差 → 样本方差（有偏 → 无偏修正）
8
    │     │     └── 等价于最小化平方和误差（第1章的误差函数）
9
    │     └── 预测分布（输出区间而非点估计）
10
    ├── 变量变换（雅可比因子 → 标准化流的基础）
11
    └── 信息论
12
          ├── 熵（不确定性度量）
13
          ├── KL散度（分布差异 → 模型训练的理论基础）
14
          ├── 条件熵（已知一个变量后剩余的不确定性）
15
          └── 互信息（变量间共享的信息量）

下一章我们会学习概率模型的估计方法——怎么用数据来拟合分布、做预测。

This rendering was automatically generated by Frosti Feed and may have formatting issues. For the best experience, please visit: https://muxiaowf.dpdns.org/blog/250901deep-learning1/

i	height	leftMax	rightMax	min(l,r)	雨水 = min-height
0	0	0	3	0	0
1	1	1	3	1	0
2	0	1	3	1	1
3	2	2	3	2	0
4	1	2	3	2	1
5	0	2	3	2	2
6	1	2	3	2	1
7	3	3	3	3	0
8	2	3	2	2	0
9	1	3	2	2	1
10	2	3	2	2	0
11	1	3	1	1	0

i	height	leftMax	rightMax	min(l,r)	雨水 = min-height
0	0	0	3	0	0
1	1	1	3	1	0
2	0	1	3	1	1
3	2	2	3	2	0
4	1	2	3	2	1
5	0	2	3	2	2
6	1	2	3	2	1
7	3	3	3	3	0
8	2	3	2	2	0
9	1	3	2	2	1
10	2	3	2	2	0
11	1	3	1	1	0

MuxiaoWF‘s

Hot100 算法笔记

LeetCode 算法笔记

通用思维套路总览

看到什么特征 → 用什么算法

DP 识别套路

链表万能套路

一、数组与哈希表

0001. 两数之和 Easy

0013. 罗马数字转整数 Easy

0041. 缺失的第一个正数 Hard

0049. 字母异位词分组 Medium

0128. 最长连续序列 Medium

0136. 只出现一次的数字 Easy

0169. 多数元素 Easy

0238. 除了自身以外数组的乘积 Medium

0283. 移动零 Easy

0560. 和为 K 的子数组 Medium

0724. 寻找数组的中心下标 Easy

1207. 独一无二的出现次数 Easy

1431. 拥有最多糖果的孩子 Easy

1679. K 和数对的最大数目 Medium

1732. 找到最高海拔 Easy

2215. 找出两数组的不同 Easy

2352. 相等行列对 Medium

3345. 最小可整除数位乘积 I Easy

3731. 找出缺失的元素 Easy

二、双指针

0011. 盛最多水的容器 Medium

0015. 三数之和 Medium

0027. 移除元素 Easy

0042. 接雨水 Hard

0088. 合并两个有序数组 Easy

0189. 轮转数组 Medium

0345. 反转字符串中的元音字母 Easy

0392. 判断子序列 Easy

0763. 划分字母区间 Medium

1768. 交替合并字符串 Easy

三、滑动窗口

0003. 无重复字符的最长子串 Medium

0076. 最小覆盖子串 Hard

0239. 滑动窗口最大值 Hard

0438. 找到字符串中所有字母异位词 Medium

0643. 子数组最大平均数 I Easy

1004. 最大连续1的个数 III Medium

1456. 定长子串中元音的最大数目 Medium

1493. 删掉一个元素以后全为 1 的最长子数组 Medium

四、二分查找

0033. 搜索旋转排序数组 Medium

0034. 在排序数组中查找元素的第一个和最后一个位置 Medium

0035. 搜索插入位置 Easy

0074. 搜索二维矩阵 Medium

0153. 寻找旋转排序数组中的最小值 Medium

0240. 搜索二维矩阵 II Medium

0287. 寻找重复数 Medium

0374. 猜数字大小 Easy

0875. 爱吃香蕉的珂珂 Medium

0004. 寻找两个正序数组的中位数 Hard

五、链表

0002. 两数相加 Medium

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

0021. 合并两个有序链表 Easy

0023. 合并 K 个升序链表 Hard

0024. 两两交换链表中的节点 Medium

0025. K 个一组翻转链表 Hard

0138. 随机链表的复制 Medium

0141. 环形链表 Easy

0142. 环形链表 II Medium

0146. LRU 缓存 Medium

0148. 排序链表 Medium

0160. 相交链表 Easy

0206. 反转链表 Easy

0234. 回文链表 Easy

0328. 奇偶链表 Medium

2095. 删除链表的中间节点 Medium

2130. 链表最大孪生和 Medium

六、栈与单调栈

0020. 有效的括号 Easy

0032. 最长有效括号 Hard

0084. 柱状图中最大的矩形 Hard

0001. 两数之和 `Easy`

0013. 罗马数字转整数 `Easy`

0041. 缺失的第一个正数 `Hard`

0049. 字母异位词分组 `Medium`

0128. 最长连续序列 `Medium`

0136. 只出现一次的数字 `Easy`

0169. 多数元素 `Easy`

0238. 除了自身以外数组的乘积 `Medium`

0283. 移动零 `Easy`

0560. 和为 K 的子数组 `Medium`

0724. 寻找数组的中心下标 `Easy`

1207. 独一无二的出现次数 `Easy`

1431. 拥有最多糖果的孩子 `Easy`

1679. K 和数对的最大数目 `Medium`

1732. 找到最高海拔 `Easy`

2215. 找出两数组的不同 `Easy`

2352. 相等行列对 `Medium`

3345. 最小可整除数位乘积 I `Easy`

3731. 找出缺失的元素 `Easy`

0011. 盛最多水的容器 `Medium`

0015. 三数之和 `Medium`

0027. 移除元素 `Easy`

0042. 接雨水 `Hard`

0088. 合并两个有序数组 `Easy`

0189. 轮转数组 `Medium`

0345. 反转字符串中的元音字母 `Easy`

0392. 判断子序列 `Easy`

0763. 划分字母区间 `Medium`

1768. 交替合并字符串 `Easy`

0003. 无重复字符的最长子串 `Medium`

0076. 最小覆盖子串 `Hard`

0239. 滑动窗口最大值 `Hard`

0438. 找到字符串中所有字母异位词 `Medium`

0643. 子数组最大平均数 I `Easy`

1004. 最大连续1的个数 III `Medium`

1456. 定长子串中元音的最大数目 `Medium`

1493. 删掉一个元素以后全为 1 的最长子数组 `Medium`

0033. 搜索旋转排序数组 `Medium`

0034. 在排序数组中查找元素的第一个和最后一个位置 `Medium`

0035. 搜索插入位置 `Easy`

0074. 搜索二维矩阵 `Medium`

0153. 寻找旋转排序数组中的最小值 `Medium`

0240. 搜索二维矩阵 II `Medium`

0287. 寻找重复数 `Medium`

0374. 猜数字大小 `Easy`

0875. 爱吃香蕉的珂珂 `Medium`

0004. 寻找两个正序数组的中位数 `Hard`

0002. 两数相加 `Medium`

0019. 删除链表的倒数第 N 个结点 `Medium`

0021. 合并两个有序链表 `Easy`

0023. 合并 K 个升序链表 `Hard`

0024. 两两交换链表中的节点 `Medium`

0025. K 个一组翻转链表 `Hard`

0138. 随机链表的复制 `Medium`

0141. 环形链表 `Easy`

0142. 环形链表 II `Medium`

0146. LRU 缓存 `Medium`

0148. 排序链表 `Medium`

0160. 相交链表 `Easy`

0206. 反转链表 `Easy`

0234. 回文链表 `Easy`

0328. 奇偶链表 `Medium`

2095. 删除链表的中间节点 `Medium`

2130. 链表最大孪生和 `Medium`

0020. 有效的括号 `Easy`

0032. 最长有效括号 `Hard`

0084. 柱状图中最大的矩形 `Hard`

0155. 最小栈 `Medium`

0394. 字符串解码 `Medium`

0735. 小行星碰撞 `Medium`

0739. 每日温度 `Medium`

2390. 从字符串中移除星号 `Medium`

0094. 二叉树的中序遍历 `Easy`

0098. 验证二叉搜索树 `Medium`

0101. 对称二叉树 `Easy`

0102. 二叉树的层序遍历 `Medium`

0104. 二叉树的最大深度 `Easy`

0105. 从前序与中序遍历序列构造二叉树 `Medium`

0108. 将有序数组转换为二叉搜索树 `Easy`

0114. 二叉树展开为链表 `Medium`

i	height	leftMax	rightMax	min(l,r)	雨水 = min-height
0	0	0	3	0	0
1	1	1	3	1	0
2	0	1	3	1	1
3	2	2	3	2	0
4	1	2	3	2	1
5	0	2	3	2	2
6	1	2	3	2	1
7	3	3	3	3	0
8	2	3	2	2	0
9	1	3	2	2	1
10	2	3	2	2	0
11	1	3	1	1	0