滑动窗口算法：原理、实现与LeetCode实战-代码聚汇网

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

超级简历WonderCV

1. 滑动窗口算法概述

滑动窗口（Sliding Window）是算法领域一种经典的优化技术，主要用于处理数组或链表这类线性数据结构上的连续子序列问题。我第一次接触这个概念是在解决LeetCode上的"最大连续子数组和"问题时，当时暴力解法的时间复杂度高达O(n²)，而引入滑动窗口后瞬间优化到O(n)。

窗口的本质是一个动态变化的区间，通过左右边界的移动来调整观察范围。就像用放大镜查看地图时，我们不会一次性看完整个地图，而是移动镜片逐步观察每个局部区域。这种思想在数据处理中极为高效，特别是当问题满足"连续性"和"单调性"这两个特征时。

关键认知：滑动窗口不是具体算法，而是一种通过维护可变区间来降低时间复杂度的思想框架。其核心价值在于将嵌套循环转化为单次遍历，通常能将O(n²)优化到O(n)。

2. 不定长滑动窗口的特性

2.1 与固定窗口的区别

固定长度滑动窗口就像用固定尺寸的相框在照片上移动，每次只查看固定数量的像素。而不定长窗口则像可伸缩的取景框，根据画面内容动态调整大小。这种灵活性使其能解决更复杂的问题，如：

寻找满足条件的最短/最长子串
包含所有指定字符的最小窗口
乘积小于K的连续子数组个数

2.2 核心操作流程

典型实现遵循以下模式：

python复制left = 0
for right in range(len(nums)):
    # 扩展窗口
    window.add(nums[right])
    
    while 不满足条件时:
        # 收缩窗口
        window.remove(nums[left])
        left += 1
    
    # 更新结果
    update_result()

2.3 时间复杂度分析

虽然代码中有嵌套循环，但每个元素最多被访问两次（加入和移除窗口），因此时间复杂度严格保持O(n)。这种均摊分析（Amortized Analysis）是理解滑动窗口效率的关键。

3. 实现要点与边界处理

3.1 窗口状态维护

高效实现需要三个核心变量：

window：当前窗口内的元素集合
left/right：窗口左右边界指针
result：存储最优解的变量

对于字符类问题，常用哈希表记录窗口内字符频次：

python复制from collections import defaultdict

def minWindow(s: str, t: str) -> str:
    need = defaultdict(int)
    for c in t:
        need[c] += 1
    
    left, valid = 0, 0
    window = defaultdict(int)
    res = ""
    
    for right in range(len(s)):
        c = s[right]
        if c in need:
            window[c] += 1
            if window[c] == need[c]:
                valid += 1
        
        while valid == len(need):
            # 更新结果
            if not res or right - left + 1 < len(res):
                res = s[left:right+1]
            
            # 收缩窗口
            d = s[left]
            if d in need:
                if window[d] == need[d]:
                    valid -= 1
                window[d] -= 1
            left += 1
    
    return res

3.2 关键边界条件

空输入处理：当输入字符串为空时应直接返回
无效情况：当目标字符集t大于s时直接返回空
多个解存在时：确保返回第一个最短解
字符大小写：明确是否区分大小写

4. 典型问题实战解析

4.1 最小覆盖子串（LeetCode 76）

给定字符串S和T，在S中找到包含T所有字符的最短子串。这是滑动窗口的经典应用，解题时需要：

统计T中字符频次（need字典）
维护窗口内字符频次（window字典）
使用valid计数器匹配满足条件的字符数

易错点：在收缩窗口时，必须先检查window[d] == need[d]再减少valid，否则会漏判。

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

找不含重复字符的连续子串的最大长度。相比前例更简单，只需维护字符最后出现位置的哈希表：

python复制def lengthOfLongestSubstring(s: str) -> int:
    last_pos = {}
    left = 0
    res = 0
    
    for right, c in enumerate(s):
        if c in last_pos and last_pos[c] >= left:
            left = last_pos[c] + 1
        last_pos[c] = right
        res = max(res, right - left + 1)
    
    return res

4.3 乘积小于K的子数组（LeetCode 713）

计算连续子数组乘积小于k的个数。这里窗口维护的是乘积值：

python复制def numSubarrayProductLessThanK(nums: List[int], k: int) -> int:
    if k <= 1: return 0
    
    prod = 1
    left = 0
    res = 0
    
    for right, num in enumerate(nums):
        prod *= num
        while prod >= k:
            prod /= nums[left]
            left += 1
        res += right - left + 1
    
    return res

5. 调试技巧与性能优化

5.1 可视化调试法

在纸上画出窗口移动过程：

code复制示例：s = "ADOBECODEBANC", t = "ABC"
步骤1: A D O B E C O D E B A N C
       ↑     ↑
       l     r (找到第一个包含ABC的窗口"ADOBEC")

步骤2: A D O B E C O D E B A N C
         ↑   ↑
         l   r (收缩窗口寻找更优解)

步骤3: A D O B E C O D E B A N C
             ↑     ↑
             l     r (找到更短的"CODEBA")

5.2 常见错误排查

窗口不收缩：忘记移动左指针导致死循环
结果更新时机错误：在收缩循环外更新结果
哈希表未初始化：直接访问不存在的key导致KeyError
指针越界：右指针超出数组长度

5.3 进阶优化方向

对于字符集固定的问题，用数组代替哈希表提升速度
预处理时先过滤掉无关字符减少遍历次数
在特定场景下使用位运算替代频次统计

6. 模式识别与解题模板

经过多个问题的实践，我总结出不定长滑动窗口的通用解题框架：

初始化窗口边界指针left=right=0
创建用于记录窗口状态的哈希表/变量
右指针移动扩展窗口，更新状态
当不满足条件时，移动左指针收缩窗口
在适当位置更新最终结果

这个模式可以解决80%以上的不定长窗口问题。关键在于准确识别：

什么是窗口的"满足条件"状态
何时应该收缩窗口
结果应该在循环的哪个阶段更新

在实际面试中，我通常会先向面试官描述这个通用思路，再根据具体问题调整实现细节。这种结构化思维能显著提高解题效率和代码质量。