【码道初阶-Hot100】LeetCode 438 + 567 对照详解：一套滑动窗口模板，彻底讲透“固定长度窗口 + 计数数组 + count维护”

LeetCode 438 + 567 对照详解：一套滑动窗口模板，彻底讲透"固定长度窗口 + 计数数组 + count维护"

摘要

很多人把 LeetCode 438 和 567 当成两道题分开记，其实完全没必要。它们本质上是同一个固定长度滑动窗口模型，真正难点只在一个地方：count 如何维护，以及为什么出窗口必须"先判后减"。这篇文章就把这两题放在一起，一次讲透。
LeetCode 438. 找到字符串中所有字母异位词 和 LeetCode 567. 字符串的排列 是两道极其相似的题。很多人会觉得它们是两道不同题，但实际上，它们的核心思路几乎一模一样：

都是在大串里找一个长度固定的窗口
都是在判断这个窗口是否和目标串字符频次一致
都可以用"计数数组 + 滑动窗口 + count 维护有效字符数"来解决

两题真正的区别只有一个：

438：要把所有合法窗口的起点都记录下来
567 ：只要发现一个合法窗口，就立刻返回 true

这篇文章就把这两题放在一起讲清楚，重点解决下面几个常见疑问：

为什么这两题本质上是同一个模型
count 到底在统计什么
为什么"进窗口先加后判，出窗口先判后减"
为什么这个顺序一旦写反就会出 bug
这两题代码到底该怎么统一记忆

[LeetCode 438 + 567 对照详解：一套滑动窗口模板，彻底讲透"固定长度窗口 + 计数数组 + count维护"](#LeetCode 438 + 567 对照详解：一套滑动窗口模板，彻底讲透“固定长度窗口 + 计数数组 + count维护”)
- 摘要
- 目录
- 一、先看两道题分别在问什么
- - [LeetCode 438：找到字符串中所有字母异位词](#LeetCode 438：找到字符串中所有字母异位词)
  - [LeetCode 567：字符串的排列](#LeetCode 567：字符串的排列)
- 二、这两题本质上是同一题
- 三、为什么一定是"固定长度滑动窗口"
- - [1. 长度相同](#1. 长度相同)
  - [2. 字符种类与数量完全相同](#2. 字符种类与数量完全相同)
- 四、统一建模：两个计数数组
- - [1. `need`](#1. need)
  - [2. `window`](#2. window)
- [五、进一步优化：为什么要引入 `count`](#五、进一步优化：为什么要引入 count)
- [六、`count` 到底在统计什么](#六、count 到底在统计什么)
- - [例子 1](#例子 1)
  - [例子 2](#例子 2)
- 七、进窗口时，为什么是"先加后判"
- 八、出窗口时，为什么是"先判后减"
- 九、最容易翻车的地方：为什么顺序写反会错
- [十、用一个经典反例说明 bug：`s = "aaab", p = "ab"`](#十、用一个经典反例说明 bug：s = "aaab", p = "ab")
- - 错误逻辑会怎么出问题
- 十一、所以这类题的万能口诀就是
- - 进窗口
  - 出窗口
[十二、LeetCode 438 标准代码（详细注释版）](#十二、LeetCode 438 标准代码（详细注释版）)
[十三、LeetCode 567 标准代码（详细注释版）](#十三、LeetCode 567 标准代码（详细注释版）)
- [十四、把 438 和 567 放在一起看，差别到底只有哪一点](#十四、把 438 和 567 放在一起看，差别到底只有哪一点)
- [十五、这两题能不能直接比较两个数组而不用 `count`](#十五、这两题能不能直接比较两个数组而不用 count)
- 十六、统一模板版写法
- 十七、复杂度分析
- - 时间复杂度
  - 空间复杂度
- 十八、面试高频追问总结
- - [1. 为什么这两题可以用同一套模板](#1. 为什么这两题可以用同一套模板)
  - [2. `count` 到底统计什么](#2. count 到底统计什么)
  - [3. 为什么 438 和 567 代码几乎一样](#3. 为什么 438 和 567 代码几乎一样)
  - [4. 为什么出窗口必须先判后减](#4. 为什么出窗口必须先判后减)
  - [5. 怎么快速记住这类题](#5. 怎么快速记住这类题)
- 十九、学习路线总结
- - 第一步：先理解固定长度窗口
  - 第二步：理解两个计数数组
  - [第三步：彻底理解 `count`](#第三步：彻底理解 count)
  - 第四步：记住状态维护顺序
  - 第五步：分清两题唯一差别
- 二十、结语

一、先看两道题分别在问什么

LeetCode 438：找到字符串中所有字母异位词

给定字符串 s 和 p，要求找出 s 中所有是 p 的字母异位词的子串起始下标。

例如：

java 复制代码

s = "cbaebabacd"
p = "abc"

输出：

java 复制代码

[0, 6]

因为：

s[0..2] = "cba" 是 "abc" 的异位词
s[6..8] = "bac" 也是 "abc" 的异位词

LeetCode 567：字符串的排列

给定字符串 s1 和 s2，判断 s2 中是否包含 s1 的某个排列。

例如：

java 复制代码

s1 = "ab"
s2 = "eidbaooo"

输出：

java 复制代码

true

因为 s2 中包含 "ba"，它是 "ab" 的一个排列。

二、这两题本质上是同一题

把两道题抽象一下，会发现它们都在做同一件事：

在大字符串中，寻找长度等于目标串长度的窗口，判断该窗口的字符频次是否和目标串一致。

也就是说：

目标串长度固定
窗口长度固定
窗口不断右移
每次判断当前窗口是否"匹配目标串的字符需求"

所以它们实际上是同一个固定长度滑动窗口模型。

三、为什么一定是"固定长度滑动窗口"

这是两题最根本的共同点。

如果一个字符串是另一个字符串的字母异位词，那么它们一定满足：

1. 长度相同

例如：

java 复制代码

"abc" 和 "cba"

长度都为 3。

2. 字符种类与数量完全相同

只是顺序不同。

所以在大串中找异位词/排列时，根本不需要考虑任意长度窗口，而只需要考虑：

长度等于目标串长度的窗口

这就是为什么这两题都天然适合固定长度滑动窗口。

四、统一建模：两个计数数组

这两题都可以定义两个数组：

1. `need`

记录目标串中每个字符需要多少个。

2. `window`

记录当前窗口中每个字符出现多少个。

例如：

java 复制代码

p = "aab"

那么：

java 复制代码

need['a'] = 2
need['b'] = 1

当窗口中字符统计刚好和 need 一致时，说明当前窗口就是一个合法答案。

五、进一步优化：为什么要引入 `count`

最直接的做法是：

每次窗口滑动后
都比较一次 need 和 window 是否完全相等

因为字符集只有 26 个小写字母，这样其实也能过。

但更常见、也更适合面试表达的方式是：

用一个 count 来维护当前窗口中"已经有效匹配上的字符总数"

这样每次就不用反复比较两个数组了。

六、`count` 到底在统计什么

这是这套模板最容易理解错的地方。

count 统计的不是：

匹配了多少种字符

而是：

匹配了多少个字符

举个例子。

例子 1

java 复制代码

p = "abc"

如果当前窗口是：

java 复制代码

"abx"

那么：

a 有效
b 有效
x 无效

所以：

java 复制代码

count = 2

例子 2

java 复制代码

p = "aab"

如果当前窗口是：

java 复制代码

"aab"

那么：

两个 a 都有效
一个 b 有效

所以：

java 复制代码

count = 3

注意这里不是 2，而是 3。

因为 count 统计的是有效字符总数，不是字符种类数。

七、进窗口时，为什么是"先加后判"

假设当前右指针加入了一个字符 c。

正确写法是：

java 复制代码

window[c]++;
if (window[c] <= need[c]) {
    count++;
}

为什么？

因为判断的是：

这个字符加入窗口之后，它是否仍然处于需求范围内。

如果加入后没有超标，那说明这次加入的是一个有效字符，于是 count++。

所以进窗口的正确顺序是：

先加桶，再判断要不要 count++

这可以记成一句话：

进窗口：先加后判

八、出窗口时，为什么是"先判后减"

假设当前左边要移出一个字符 c。

正确写法是：

java 复制代码

if (window[c] <= need[c]) {
    count--;
}
window[c]--;

为什么？

因为判断的是：

这个字符离开窗口之前，它是否正在为 count 作贡献。

如果离开前它是有效字符，那么它离开后，count 就必须减 1。

但如果它离开前其实是"多余字符"，那它本来就没在贡献 count，自然不能减。

所以出窗口的正确顺序是：

先判断要不要 count--，再减桶

这可以记成一句话：

出窗口：先判后减

九、最容易翻车的地方：为什么顺序写反会错

这个 bug 非常经典。

假设错误写法是：

java 复制代码

window[c]--;
if (window[c] <= need[c]) {
    count--;
}

问题在于：

某个字符原本可能是"多余的"
它移出后，桶值刚好回到合法区间
于是程序误以为"移出去的是有效字符"
错误地执行了 count--

但实际上：

从"超标"减到"刚好合法"，说明移出去的是多余字符，它本来就没有给 count 作贡献。

所以这种写法会把 count 维护错。

十、用一个经典反例说明 bug：`s = "aaab", p = "ab"`

目标需求：

java 复制代码

a:1
b:1

窗口长度：

java 复制代码

m = 2

正确答案是：

java 复制代码

[2]

因为 "ab" 是合法异位词窗口。

错误逻辑会怎么出问题

当窗口从 "aab" 收缩为 "ab" 时，移出去的是一个"多余的 a"。

这个 a 本来就不该影响 count。

但如果写成：

java 复制代码

window[a]--;
if (window[a] <= need[a]) {
    count--;
}

那么：

原本 window[a] = 2
移出后变成 1
1 <= 1 成立
程序就错误执行了 count--

结果合法窗口 "ab" 被错判掉。

十一、所以这类题的万能口诀就是

对于这种"固定长度窗口 + count维护有效字符数"的题，务必记住：

进窗口

java 复制代码

先加后判

出窗口

java 复制代码

先判后减

也就是：

java 复制代码

进：window++，再判断 count++
出：先判断 count--，再 window--

这句口诀对于 438 和 567 都通用。

十二、LeetCode 438 标准代码（详细注释版）

java 复制代码

import java.util.*;

class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        List<Integer> res = new ArrayList<>();

        int m = p.length();

        // need 记录目标串 p 的字符需求
        int[] need = new int[26];
        for (char c : p.toCharArray()) {
            need[c - 'a']++;
        }

        // window 记录当前滑动窗口中的字符统计
        int[] window = new int[26];

        int left = 0;
        int count = 0;

        // right 作为窗口右边界不断扩张
        for (int right = 0; right < s.length(); right++) {
            int idxR = s.charAt(right) - 'a';

            // 进窗口：先加桶
            window[idxR]++;

            // 如果加入后该字符仍在需求范围内，说明它是有效字符
            if (window[idxR] <= need[idxR]) {
                count++;
            }

            // 保证窗口长度不超过 m
            if (right - left + 1 > m) {
                int idxL = s.charAt(left) - 'a';

                // 出窗口：先判断这个字符离开前是否有效
                if (window[idxL] <= need[idxL]) {
                    count--;
                }

                // 再真正移出窗口
                window[idxL]--;
                left++;
            }

            // 如果有效字符总数刚好等于 m
            // 说明当前长度为 m 的窗口完全匹配 p
            if (count == m) {
                res.add(left);
            }
        }

        return res;
    }
}

十三、LeetCode 567 标准代码（详细注释版）

这题和 438 唯一的区别就是：

438：把所有合法窗口的起点收集起来
567：只要找到一个合法窗口，立刻返回 true

java 复制代码

class Solution {
    public boolean checkInclusion(String s1, String s2) {
        int m = s1.length();

        // 如果目标串比原串还长，不可能存在排列
        if (m > s2.length()) return false;

        int[] need = new int[26];
        for (char c : s1.toCharArray()) {
            need[c - 'a']++;
        }

        int[] window = new int[26];
        int left = 0;
        int count = 0;

        for (int right = 0; right < s2.length(); right++) {
            int idxR = s2.charAt(right) - 'a';

            // 进窗口：先加后判
            window[idxR]++;
            if (window[idxR] <= need[idxR]) {
                count++;
            }

            // 保证窗口长度不超过 m
            if (right - left + 1 > m) {
                int idxL = s2.charAt(left) - 'a';

                // 出窗口：先判后减
                if (window[idxL] <= need[idxL]) {
                    count--;
                }
                window[idxL]--;
                left++;
            }

            // 只要发现一个合法窗口，就返回 true
            if (count == m) {
                return true;
            }
        }

        return false;
    }
}

十四、把 438 和 567 放在一起看，差别到底只有哪一点

其实模板完全一样，唯一差别就在最后一步。

438

找到合法窗口后：

java 复制代码

res.add(left);

因为要记录所有答案。

567

找到合法窗口后：

java 复制代码

return true;

因为只要存在一个就行。

所以这两题的本质区别就是

438：求所有
567：求是否存在

这也是为什么很多刷题经验里会把这两题当作"同模板题"。

十五、这两题能不能直接比较两个数组而不用 `count`

可以。

例如每次窗口长度等于 m 时，直接比较：

java 复制代码

Arrays.equals(need, window)

也能做出来，而且因为数组长度固定为 26，时间也不算大。

不过如果是从"模板"和"面试表达"的角度来看，count 写法更值得掌握，因为它更有迁移性，后面很多滑动窗口题都能复用这套思维。

十六、统一模板版写法

如果只想记一个最核心的模板，可以记成下面这样。

java 复制代码

int[] need = new int[26];
int[] window = new int[26];
int left = 0, count = 0;

for (int right = 0; right < s.length(); right++) {
    int idxR = s.charAt(right) - 'a';

    // 进窗口：先加后判
    window[idxR]++;
    if (window[idxR] <= need[idxR]) {
        count++;
    }

    // 超长就收缩
    if (right - left + 1 > targetLen) {
        int idxL = s.charAt(left) - 'a';

        // 出窗口：先判后减
        if (window[idxL] <= need[idxL]) {
            count--;
        }
        window[idxL]--;
        left++;
    }

    // 判断当前窗口是否满足条件
    if (count == targetLen) {
        // 438：记录答案
        // 567：直接返回 true
    }
}

这就是这两题共同的核心模板。

十七、复杂度分析

两题复杂度完全一样。

时间复杂度

右指针从左到右扫描一遍
左指针也只会单调右移

所以总时间复杂度是：

java 复制代码

O(n)

其中 n 是大串长度。

空间复杂度

只用了若干长度为 26 的数组：

java 复制代码

O(1)

因为字符集固定。

十八、面试高频追问总结

1. 为什么这两题可以用同一套模板

因为它们本质都是"固定长度窗口中，判断字符频次是否匹配目标串"。

2. `count` 到底统计什么

统计的是"窗口中有效匹配的字符总数"，不是字符种类数。

3. 为什么 438 和 567 代码几乎一样

因为它们的判断条件和窗口维护方式完全一致，只是最终返回结果不同。

4. 为什么出窗口必须先判后减

因为要判断的是字符离开窗口之前是否有效，而不是离开之后是否落回合法区间。

5. 怎么快速记住这类题

记住这句就够了：

进窗口先加后判，出窗口先判后减。

十九、学习路线总结

真正掌握这两题，建议按下面顺序理解：

第一步：先理解固定长度窗口

因为异位词/排列一定和目标串长度相同。

第二步：理解两个计数数组

need 表示目标需求
window 表示当前窗口

第三步：彻底理解 `count`

它维护的是已经匹配上的字符总数。

第四步：记住状态维护顺序

这是最关键、也最容易翻车的地方：

进窗口先加后判，出窗口先判后减

第五步：分清两题唯一差别

438：记录所有起点
567：找到一个就返回

二十、结语

LeetCode 438 和 LeetCode 567 是非常适合放在一起学习的两道题。它们看起来题意不同，但本质是同一个滑动窗口模型的两个变体。

真正值得掌握的不是死记某一份代码，而是下面这套统一思维：

目标串给出字符需求
固定长度窗口在大串中滑动
window 维护窗口字符统计
count 维护有效字符总数
进窗口先加后判
出窗口先判后减

只要这套框架真正吃透，后面再遇到很多固定窗口类字符串题，都会轻松很多。

【码道初阶-Hot100】LeetCode 438 + 567 对照详解：一套滑动窗口模板，彻底讲透“固定长度窗口 + 计数数组 + count维护”

LeetCode 438 + 567 对照详解：一套滑动窗口模板，彻底讲透"固定长度窗口 + 计数数组 + count维护"

摘要

目录

文章目录

一、先看两道题分别在问什么

LeetCode 438：找到字符串中所有字母异位词

LeetCode 567：字符串的排列

二、这两题本质上是同一题

三、为什么一定是"固定长度滑动窗口"

1. 长度相同

2. 字符种类与数量完全相同

四、统一建模：两个计数数组

1. need

2. window

五、进一步优化：为什么要引入 count

六、count 到底在统计什么

例子 1

例子 2

七、进窗口时，为什么是"先加后判"

八、出窗口时，为什么是"先判后减"

九、最容易翻车的地方：为什么顺序写反会错

十、用一个经典反例说明 bug：s = "aaab", p = "ab"

错误逻辑会怎么出问题

十一、所以这类题的万能口诀就是

进窗口

出窗口

十二、LeetCode 438 标准代码（详细注释版）

十三、LeetCode 567 标准代码（详细注释版）

十四、把 438 和 567 放在一起看，差别到底只有哪一点

438

567

所以这两题的本质区别就是

十五、这两题能不能直接比较两个数组而不用 count

十六、统一模板版写法

十七、复杂度分析

时间复杂度

空间复杂度

十八、面试高频追问总结

1. 为什么这两题可以用同一套模板

2. count 到底统计什么

3. 为什么 438 和 567 代码几乎一样

4. 为什么出窗口必须先判后减

5. 怎么快速记住这类题

十九、学习路线总结

第一步：先理解固定长度窗口

第二步：理解两个计数数组

第三步：彻底理解 count

第四步：记住状态维护顺序

第五步：分清两题唯一差别

二十、结语

1. `need`

2. `window`

五、进一步优化：为什么要引入 `count`

六、`count` 到底在统计什么

十、用一个经典反例说明 bug：`s = "aaab", p = "ab"`

十五、这两题能不能直接比较两个数组而不用 `count`

2. `count` 到底统计什么

第三步：彻底理解 `count`