滑动窗口算法详解：原理、实现与LeetCode实战

1. 滑动窗口算法入门指南

第一次接触滑动窗口算法是在解决LeetCode第3题"无重复字符的最长子串"时。当时我用了暴力解法，时间复杂度高达O(n²)，提交后直接超时。后来看到讨论区有人提到"滑动窗口"这个神奇的概念，只用O(n)时间就解决了问题，从此打开了新世界的大门。

滑动窗口本质上是一种双指针技巧的变体，特别适合解决数组/字符串的子区间问题。它通过维护一个动态变化的窗口来避免重复计算，把很多看似需要O(n²)的问题优化到O(n)时间复杂度。在实际面试中，滑动窗口类题目出现的频率极高，是算法准备中必须掌握的利器。

2. 滑动窗口核心原理剖析

2.1 基本概念与适用场景

滑动窗口算法主要用于解决数组或字符串的连续子区间问题。典型场景包括：

• 寻找满足特定条件的最长子串/子数组
• 计算满足条件的子串/子数组数量
• 求包含所有指定元素的最短区间

这类问题的共同特点是都需要考察输入序列的某个连续区间，而滑动窗口可以高效地枚举所有可能的区间，同时避免重复计算。

2.2 算法框架与实现模板

经过几十道题的实战，我总结出了一个通用的滑动窗口模板：

python复制def slidingWindow(s: str, t: str) -> str:
    # 初始化哈希表和计数器
    need = collections.defaultdict(int)
    for c in t:
        need[c] += 1
    count = len(t)
    
    left = right = 0  # 窗口左右边界
    min_len = float('inf')  # 记录最小窗口长度
    result = ""
    
    while right < len(s):
        # 右边界扩展
        if s[right] in need:
            if need[s[right]] > 0:
                count -= 1
            need[s[right]] -= 1
        
        # 满足条件时收缩左边界
        while count == 0:
            # 更新结果
            if right - left + 1 < min_len:
                min_len = right - left + 1
                result = s[left:right+1]
            
            # 左边界移动
            if s[left] in need:
                need[s[left]] += 1
                if need[s[left]] > 0:
                    count += 1
            left += 1
            
        right += 1
    
    return result

这个模板适用于大多数滑动窗口问题，只需根据具体题目调整条件判断和结果更新部分。

3. 经典题目实战解析

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

这是滑动窗口最经典的入门题。给定一个字符串，找出不含有重复字符的最长子串的长度。

python复制def lengthOfLongestSubstring(s: str) -> int:
    char_index = {}  # 记录字符最后出现的位置
    left = max_len = 0
    
    for right, char in enumerate(s):
        if char in char_index and char_index[char] >= left:
            left = char_index[char] + 1
        char_index[char] = right
        max_len = max(max_len, right - left + 1)
    
    return max_len

关键点：

1. 使用哈希表记录字符最后出现的位置
2. 当遇到重复字符时，快速移动左指针到重复字符的下一个位置
3. 每次迭代都更新最大长度

时间复杂度O(n)，空间复杂度O(min(m,n))，其中m是字符集大小。

3.2 最小覆盖子串（LeetCode 76）

给定字符串S和T，在S中找到包含T所有字符的最短子串。

python复制def minWindow(s: str, t: str) -> str:
    from collections import defaultdict
    
    need = defaultdict(int)
    for c in t:
        need[c] += 1
    count = len(t)
    
    left = 0
    min_len = float('inf')
    result = ""
    
    for right, char in enumerate(s):
        if char in need:
            if need[char] > 0:
                count -= 1
            need[char] -= 1
        
        while count == 0:
            if right - left + 1 < min_len:
                min_len = right - left + 1
                result = s[left:right+1]
            
            left_char = s[left]
            if left_char in need:
                need[left_char] += 1
                if need[left_char] > 0:
                    count += 1
            left += 1
    
    return result

这个实现完美展示了滑动窗口的典型结构：

1. 右指针扩展窗口，直到满足条件
2. 左指针收缩窗口，寻找最优解
3. 在窗口满足条件时更新结果

3.3 字符串的排列（LeetCode 567）

判断s2是否包含s1的排列，即是否存在s2的子串是s1的某种排列。

python复制def checkInclusion(s1: str, s2: str) -> bool:
    from collections import defaultdict
    
    need = defaultdict(int)
    for c in s1:
        need[c] += 1
    count = len(s1)
    
    left = 0
    for right, char in enumerate(s2):
        if char in need:
            if need[char] > 0:
                count -= 1
            need[char] -= 1
        
        while right - left + 1 > len(s1):
            left_char = s2[left]
            if left_char in need:
                need[left_char] += 1
                if need[left_char] > 0:
                    count += 1
            left += 1
        
        if count == 0 and right - left + 1 == len(s1):
            return True
    
    return False

这道题的技巧在于窗口大小固定为s1的长度，只需检查是否存在某个窗口的字符计数与s1完全匹配。

4. 滑动窗口的变体与优化

4.1 可变窗口与固定窗口

滑动窗口问题可以分为两大类：

1. 可变窗口大小：如最小覆盖子串、无重复字符的最长子串
2. 固定窗口大小：如字符串的排列、找所有字母异位词

固定窗口问题通常更简单，因为不需要维护窗口的最大/最小条件，只需滑动窗口并检查每个位置即可。

4.2 多指针滑动窗口

有些复杂问题可能需要维护多个指针。例如LeetCode 424"替换后的最长重复字符"，需要同时维护窗口的左边界和当前最大计数字符的位置。

python复制def characterReplacement(s: str, k: int) -> int:
    count = {}
    max_count = left = max_len = 0
    
    for right, char in enumerate(s):
        count[char] = count.get(char, 0) + 1
        max_count = max(max_count, count[char])
        
        if (right - left + 1 - max_count) > k:
            count[s[left]] -= 1
            left += 1
        
        max_len = max(max_len, right - left + 1)
    
    return max_len

这个实现巧妙地使用max_count来跟踪窗口内最多出现的字符数，避免每次重新计算。

4.3 滑动窗口与其他算法的结合

滑动窗口常与其他算法结合使用：

• 与哈希表结合：用于字符计数和快速查找
• 与前缀和结合：解决子数组求和问题
• 与单调队列结合：解决滑动窗口最大值问题

例如LeetCode 239"滑动窗口最大值"就使用了单调队列来优化：

python复制def maxSlidingWindow(nums: List[int], k: int) -> List[int]:
    from collections import deque
    
    q = deque()
    result = []
    
    for i, num in enumerate(nums):
        while q and nums[q[-1]] < num:
            q.pop()
        q.append(i)
        
        if q[0] == i - k:
            q.popleft()
        
        if i >= k - 1:
            result.append(nums[q[0]])
    
    return result

5. 常见错误与调试技巧

5.1 边界条件处理

滑动窗口算法最容易出错的就是边界条件：

• 窗口初始状态
• 左右指针移动条件
• 结果更新时机

建议在纸上画出窗口移动过程，特别是处理以下情况：

• 空字符串输入
• 所有字符都相同的情况
• 目标字符串比源字符串长的情况

5.2 哈希表计数陷阱

使用哈希表记录字符出现次数时，常见错误包括：

1. 混淆字符增加和减少的逻辑
2. 错误处理计数为0的情况
3. 忘记初始化哈希表

调试时可以打印窗口状态和哈希表内容：

python复制print(f"Window: [{left}, {right}], Count: {count}, Hash: {need}")

5.3 性能优化技巧

当处理大规模数据时，可以考虑：

1. 提前终止：找到解后立即返回
2. 空间优化：用数组代替哈希表（当字符集有限时）
3. 并行处理：对大规模数据可分块处理

例如对于仅包含小写字母的问题，可以用长度为26的数组代替哈希表：

python复制count = [0] * 26
for c in t:
    count[ord(c) - ord('a')] += 1

6. 滑动窗口问题分类训练

为了系统掌握滑动窗口，建议按以下类别刷题：

6.1 基础窗口滑动

• 最大连续1的个数 III（LeetCode 1004）
• 爱生气的书店老板（LeetCode 1052）

6.2 字符串包含问题

• 找到字符串中所有字母异位词（LeetCode 438）
• 最短超串（LeetCode 面试题17.18）

6.3 子数组/子序列问题

• 和至少为K的最短子数组（LeetCode 862）
• 乘积小于K的子数组（LeetCode 713）

6.4 多指针窗口

• 至多包含两个不同字符的最长子串（LeetCode 159）
• 至多包含K个不同字符的最长子串（LeetCode 340）

7. 面试实战建议

在技术面试中遇到滑动窗口问题时，建议采取以下步骤：

1. 明确问题：确认输入输出要求，特别是边界条件
2. 暴力分析：先思考暴力解法，明确优化方向
3. 滑动窗口：识别窗口移动条件，设计指针移动逻辑
4. 优化验证：通过测试用例验证正确性和效率

面试官常考察的点包括：

• 能否识别出滑动窗口适用场景
• 指针移动条件的正确性
• 时间/空间复杂度分析能力
• 代码实现的简洁性和鲁棒性

练习时建议先用伪代码写出框架，再填充具体实现细节，这样可以避免陷入编码细节而忽略整体逻辑。