--- tags: ["LeetCode", "滑动窗口", "哈希表", "中等"] create time: 2026-05-14 10:30 --- # 09-找到字符串中所有字母异位词 ## 题面 给定两个字符串 `s` 和 `p`，找到 `s` 中所有 `p` 的 **异位词** 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。 > [!question] 💡 什么是"异位词"？ > 两个字符串包含完全相同的字符，且每个字符出现的次数也相同——仅仅是排列顺序不同。例如 `"abc"` 和 `"cba"`、`"bca"` 互为异位词。 **示例 1：** ``` 输入: s = "cbaebabacd", p = "abc" 输出: [0,6] 解释: 起始索引等于 0 的子串是 "cba"，它是 "abc" 的异位词。 起始索引等于 6 的子串是 "bac"，它是 "abc" 的异位词。 ``` **示例 2：** ``` 输入: s = "abab", p = "ab" 输出: [0,1,2] 解释: 起始索引等于 0 的子串是 "ab"，它是 "ab" 的异位词。 起始索引等于 1 的子串是 "ba"，它是 "ab" 的异位词。 起始索引等于 2 的子串是 "ab"，它是 "ab" 的异位词。 ``` **提示：** - `1 <= s.length, p.length <= 3 * 10^4` - `s` 和 `p` 仅包含小写英文字母 --- ## 思路 > [!info] 🎯 核心观察 > 异位词的长度是固定的（等于 `len(p)`），所以本质上是：在字符串 `s` 上维护一个**长度固定为 len(p)** 的滑动窗口，逐一检查窗口内的字符组成是否与 `p` 一致。这比一般的"可变长窗口"更简单——左指针的移动节奏由右指针决定：每前进一格，左右各前进一步。 ### 方法一：暴力枚举 ❌ 枚举 `s` 中所有长度为 `len(p)` 的子串，对每个子串排序后与排序后的 `p` 比较。 - **时间复杂度：O((m-n+1) · n · log n)** — 每个子串排序需要 O(n log n)，共有 m-n+1 个子串（m = len(s)） - **空间复杂度：O(n)** — 排序需要的额外空间 当 `n` 较大时，这种做法明显超时，需要利用"滑动窗口增量更新"来避免重复排序。 ### 方法二：定长滑动窗口 + 计数数组 ⭐（最优） > [!abstract] 🔍 为什么用数组而非哈希表？ > 题目限定只包含小写英文字母，字符集大小固定为 26。此时用 `int[26]` 数组比 `map[rune]int` 哈希表更快——数组不存在 hash 计算开销，内存也更紧凑。 #### 算法步骤 **第一步：统计 `p` 中各字符出现频次。** 用一个长度为 26 的数组 `pCount` 记录 `p` 的字符频率分布。 **第二步：在 `s` 上维护长度为 `len(p)` 的滑动窗口。** 初始时，让窗口覆盖 `s[0..len(p)-1]`。这里需要**分别统计**——`pCount` 记录 `p` 的字符频率，`windowCount` 记录窗口内（即 `s[0..len(p)-1]`）的字符频率，然后比较两者是否相等。之后每次窗口向右移动一格：新字符从右侧进入窗口并计入 `windowCount`，左侧离开窗口的字符从 `windowCount` 中减去。每次移动后再次比较两个数组。 ```mermaid flowchart TD Start["初始化 pCount 统计 p 的字符频次"] --> InitWin["初始化 windowCount 统计 s 前 n 个字符频次"] InitWin --> CheckStart{"pCount == windowCount"} CheckStart -->|"是"| Add0["将索引 0 加入结果"] CheckStart -->|"否"| SkipStart["跳过"] Add0 --> EnterLoop["进入循环 i 从 n 到 m-1"] SkipStart --> EnterLoop EnterLoop --> RightIn["右进新字符加入窗口"] RightIn --> LeftOut["左出旧字符离开窗口"] LeftOut --> CheckWin{"pCount == windowCount"} CheckWin -->|"是"| AddIdx["将索引 i-n+1 加入结果"] CheckWin -->|"否"| SkipWin["跳过"] AddIdx --> LoopCheck{"i < m"} SkipWin --> LoopCheck LoopCheck -->|"是"| EnterLoop LoopCheck -->|"否"| ReturnRes["返回结果数组"] ``` #### 逐步推演 以 `s = "abab", p = "ab"` 为例（匹配场景）： | 阶段 | 操作 | pCount | windowCount | 匹配? | 结果 | |------|------|--------|-------------|-------|------| | 初始化窗口 | 统计 `s[0..1]="ab"` | `{a:1, b:1}` | `{a:1, b:1}` | ✅ | `[0]` | | 窗口右移 (i=2) | 进 `'a'`，出 `s[0]='a'` | `{a:1, b:1}` | `{a:1, b:1}` | ✅ | `[0, 1]` | | 窗口右移 (i=3) | 进 `'b'`，出 `s[1]='b'` | `{a:1, b:1}` | `{a:1, b:1}` | ✅ | `[0, 1, 2]` | 再看一个有匹配也有不匹配的例子 `s = "cbaebabacd", p = "abc"`（以下为完整推演，超出原题示例范围）： | i | 窗口内容 | 窗口频次分布 | 匹配? | 结果追加 | |----|---------|------------|-------|---------| | 初始 | `"cba"` | `{a:1, b:1, c:1}` | ✅ | `[0]` | | 3 | `"bae"` | `{a:1, b:1, e:1}` | ❌ | — | | 4 | `"aeb"` | `{a:1, b:1, e:1}` | ❌ | — | | 5 | `"eba"` | `{a:1, b:1, e:1}` | ❌ | — | | 6 | `"bac"` | `{a:1, b:1, c:1}` | ✅ | `[0, 6]` | | 7 | `"acb"` | `{a:1, b:1, c:1}` | ✅ | `[0, 6, 7]` | | 8 | `"cba"` | `{a:1, b:1, c:1}` | ✅ | `[0, 6, 7, 8]` | 最终结果为 `[0, 6, 7, 8]`。（注意题目示例只列出前两个答案 `[0, 6]`，实际完整输出为全部四个索引。） > [!note] 🧠 "右进左出"的增量更新技巧 > 窗口每次右移一格时，只需做两次 O(1) 的加减操作：`windowCount[newChar]++` 和 `windowCount[oldChar]--`，无需重新统计整个窗口。这是滑动窗口把时间复杂度从 O(m·n) 优化到 O(m) 的关键。 > [!tip] 🔑 数组比较的小优化 > 如果只想判断窗口状态有无变化，可以维护一个变量 `matches`（或 `diff`），记录当前有多少个位置的频次已经对齐。但这会增加代码复杂度，对于本题常数级比较（26次）而言优化意义不大，保持简洁即可。 **时间复杂度：O(m)** — 先遍历 `p` 一次 O(n)，再遍历 `s` 一次 O(m)。窗口内的数组比较虽然做了 26 次元素对比，但 26 是常量，均摊后仍为 O(m)。 **空间复杂度：O(1)** — 只用到了固定大小的数组（26 个整型元素）。 --- ## 代码提示 ``` // 伪代码模板 m = len(s) n = len(p) if n > m: return [] pCount = 数组[int](26) // 记录 p 的字符频次 windowCount = 数组[int](26) // 记录当前窗口的字符频次 // 初始化: 统计 p 和 s 前 n 个字符的频次 for i = 0 到 n-1: pCount[p[i]-'a']++ windowCount[s[i]-'a']++ result = [] // 检查初始窗口 if arraysEqual(pCount, windowCount): result.append(0) // 滑动窗口: 逐个右移 for i = n 到 m-1: windowCount[s[i]-'a']++ // 新字符入 windowCount[s[i-n]-'a']-- // 旧字符出 if arraysEqual(pCount, windowCount): result.append(i - n + 1) return result ``` Go 语言中利用数组类型天然支持 `==` 运算符的特性，可直接比较两个 `[26]int`： ```go // Go 风格精简版骨架 var pCount, windowCount [26]int // [26]int 天然支持 == 比较 for _, ch := range p { pCount[ch-'a']++ } for i := 0; i < len(p); i++ { windowCount[s[i]-'a']++ } // 💡 Go 优化：预先分配容量，避免运行时多次扩容（上限为 m-n+1） result := make([]int, 0, len(s)-len(p)+1) if pCount == windowCount { result = append(result, 0) } for i := len(p); i < len(s); i++ { windowCount[s[i]-'a']++ windowCount[s[i-len(p)]-'a']-- if pCount == windowCount { result = append(result, i-len(p)+1) } } ``` > [!note] 🐹 Go 中 `[26]int ==` 的特性 > Go 语言的数组是值类型，两个同构的 `[N]int` 数组可以直接用 `==` 逐元素比较，这在其他语言中并不常见。这省去了手写循环比对的时间，让代码异常简洁。 --- ## 技巧 > [!tip] 🔑 固定窗口 vs 可变窗口 > > | 场景 | 窗口行为 | 典型问题 | > |------|---------|---------| > | **固定长度** | 右指针每进一格，左指针也相应前进一格 | 字母异位词、大小为 K 的子数组平均值 | > | **可变长度** | 左右指针独立运动，按条件伸缩 | 无重复字符最长子串、最小覆盖子串 | > > 本题是"固定窗口"范式——只要知道窗口大小 `n`，左右指针步调就锁定了：`left = right - n + 1`。识别这一点可以避免过度设计。 > [!info] 📊 字符集大小决定数据结构 > > | 字符集限制 | 推荐方案 | 理由 | > |-----------|---------|------| > | 仅小写字母（如本题） | `[26]int` 数组 | 常数快、内存紧、Go 支持 `==` 直接比较 | > | Unicode/任意字符 | `map[rune]int` | 灵活但慢，Go 中不支持 `==` 比较 map | > > 面试时可以主动确认："题目中的字符范围是否可以用定长数组表示？"这体现了你对边界条件的敏感度。 > [!danger] ⚠️ 常见陷阱 > > **① p 的长度大于 s**：此时不可能存在异位词，应提前返回空数组。否则窗口初始化时会越界访问 `s[n-1]`。 > > **② 混淆异位词与最长公共子串**：异位词只看字符集合和频次，不要求连续或有序。例如 `"abc"` 的异位词是 `"acb"`, `"bca"`, `"cab"`, `"cba"` 等全排列。 > > **③ Go 中 string 索引返回的是 byte 而非 rune**：由于题目限定仅含小写字母，每个字符恰好占 1 字节，直接用 `s[i]-'a'` 是正确的。但如果题目涉及多字节 Unicode 字符，则必须改用 `[]rune(s)` 转换后再索引。 --- ## 代码 ```go func findAnagrams(s string, p string) []int { m, n := len(s), len(p) if n > m { return nil } var pCount, windowCount [26]int // 统计字符频次，[26]int 天然支持 == 比较 // 初始化: 分别统计 p 和 s 的前 n 个字符的频次 for _, ch := range p { pCount[ch-'a']++ } for i := 0; i < n; i++ { windowCount[s[i]-'a']++ } // 💡 预分配容量，避免运行时多次扩容（上限为 m-n+1） result := make([]int, 0, m-n+1) // 检查第一个窗口 if pCount == windowCount { result = append(result, 0) } // 滑动窗口: 逐个右移 for i := n; i < m; i++ { windowCount[s[i]-'a']++ // 新字符从右侧进入窗口 windowCount[s[i-n]-'a']-- // 左侧字符离开窗口 if pCount == windowCount { result = append(result, i-n+1) } } return result } ``` > [!success] ✅ 运行验证 > - **LeetCode 第 438 题**，通过率约 56%，中等难度中滑动窗口的经典应用。 > - 这道题的核心洞察是：**异位词的本质是"字符频次分布相同"**。只要窗口内各字符的出现次数与 `p` 一模一样，无论顺序如何，就是异位词。固定长度的窗口设计让左右指针的运动被完全绑定，简化了逻辑。 > - 与 [[08-无重复字符的最长子串]] 对比：后者是"最大化窗口"（窗口可缩可扩），本题是"固定窗口"（窗口大小锁定）。两者的共同点都是利用增量更新避免重复计算，是理解滑动窗口的两块基石。 > - **变体延伸**：若将"完全匹配"放宽为"至多差 k 个字符"（LeetCode 2425 思路的变形），则可将数组比较替换为维护一个 `diff` 计数器——记录当前有多少个位置的频次对齐，仅当 `diff == 26` 时才记入答案，时间复杂度仍为 O(m)。