滑动窗口最大值：从暴力到单调队列的完整进阶指南

上周有个学弟把一道题目的截图发给我，标题是“剑指offer-64、滑动窗口的最大值”。他说自己用双层循环写完了，样例也过了，但提交到力扣却提示超时。我看了一眼代码，问题非常典型——在没有题目数据范围的情况下，很容易写出能跑但不合格的解法。滑动窗口的最大值这道题，几乎可以称为面试中“数组 + 双端队列”的组合经典，它的本质不是让你用 max() 函数扫窗口，而是要设计一种能随窗口移动而自然更新的数据结构。

简单描述一下题目：给定一个数组 nums 和滑动窗口大小 k，窗口每次从数组最左端移动到最右端，每次移动一位，要求返回一个数组，内容是从左到右每个窗口中的最大值。如果你正在准备算法面试、春招秋招，或者只是想弄懂单调队列，这篇内容会从头帮你说清楚：暴力为什么慢、单调队列为什么快、代码怎么写才不翻车、面试官可能追问什么。

我见过不少候选人，这道题能给出单调队列解法的，基本都能把栈、队列、双指针这一串知识串起来。反之，如果只会背模板，一旦面试官把 k 改成 1、把数组拉长、或者问“队列里为什么存下标”，能对答如流的人少之又少。这篇文章就是按我自己的理解，把这个题拆成一层层讲明白。标题里的剑指offer-64，我更愿意把它看成一道面试真题，而不是一道需要背答案的编号题。

1. 题目重述：返回每个滑动窗口内的最大值

1.1 题目描述与一个具体例子

不要嫌我啰嗦，先把题面说清楚。题目会给你一个整数数组，比如 [1, 3, -1, -3, 5, 3, 6, 7]，再给你一个窗口大小 k = 3。窗口从左往右滑，每次移动一格，停在每个位置时，窗口里都有连续的 k 个数，你的任务是把这个窗口里的最大值依次记录下来。

以下面这个例子来看：

最终返回的数组就是 [3, 3, 5, 5, 6, 7]。

有些题目变体还会说“如果数组为空返回空结果”，这些边界后面专门单开一节讲。你只需要先抓住核心：数组长度是 n，返回数组长度一定是 n - k + 1，因为窗口总数就是这么多。

1.2 这题真正想考察什么

如果只是要一个结果，很多编程语言自带 max 函数，最笨的办法就是每个窗口都调一次 max，代码写出来非常短。但面试官不会因为你写出这种解法就放过你。

这道题被《剑指Offer》收录，放在“栈与队列”专题附近，目的是考察你是否理解队列这种先进先出的结构和“滑动窗口”的匹配关系。窗口每次向右移动，左侧出去一个元素，右侧进来一个元素，这和队列的出队、入队操作一模一样。难点在于：队列不只要管元素进出的顺序，还要能快速回答“当前队列里的最大值是谁”。

如果只维护一个变量记录当前最大值，窗口右移时一旦这个最大值被移出窗口，你无法立刻知道下一个最大值是谁。所以需要队列里存的不是一个元素，而是一组候选元素，并且这组候选元素要按“对答案的贡献程度”排序。能担起这个任务的数据结构，就是单调队列。

2. 暴力解法能过样例，但天花板太低

2.1 直接扫描每个窗口的写法

先别想着一步到位写奇技淫巧。任何一个面试者在看到题目后，至少应该能先说出最简单的解法：枚举每个窗口起点，然后在这个窗口范围内线性扫描找最大值。

用 C++ 写大概是这样：

cpp复制class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> ans;
        int n = nums.size();
        for (int i = 0; i + k <= n; i++) {
            int curMax = nums[i];
            for (int j = i; j < i + k; j++) {
                curMax = max(curMax, nums[j]);
            }
            ans.push_back(curMax);
        }
        return ans;
    }
};

内层循环每次从窗口起点扫到终点，找出最大值。这个代码在 k 很小的时候跑起来没问题，例如 n=10000、k=10 时，只需要大约 10 万次比较，毫秒级就能结束。

2.2 复杂度推演和“只维护一个 max 变量”为什么不行

暴力解法的时间复杂度是 O(n * k)。n 是数组长度，k 是窗口大小。k 越接近 n，复杂度越接近 O(n^2)。当 n 到了 10 万级别，k 是 5 万，内层循环要跑大约 50 亿次，任何在线评测系统都会让你超时。

你可能会有个朴素想法：我能不能记录上一次窗口的最大值？窗口右移时，如果新进来的数比当前最大值大，就更新最大值；如果移出去的不是最大值，就直接用旧最大值；如果移出去的恰好是最大值，那再从窗口里重新找一次最大值。听起来可行，但一旦最大值被移出，重新找一次仍然需要 O(k)，最坏情况下很可能每个窗口都要重新找。比如窗口内的数字是递减序列，最大值在窗口最左边，每次滑动都会把最大值移出，每次都触发 O(k) 的重扫，复杂度依然是 O(n * k)。

所以问题的真正难点在于：你需要一种机制，在最大值离开后，能立刻从剩余的候选中找到“第二大的值”；当第二大的离开后，又能立刻找到“第三大的值”。候选元素要按照大小关系排好序，并且支持快速淘汰过期元素。这正是单调队列出场的理由。

3. 单调队列：把无用的候选元素提前扔掉

3.1 一句话建立直觉

单调队列的思路可以这样理解：队列里保存的并不是窗口里的全部元素，而是“当前窗口内，未来有可能成为最大值”的元素集合，而且这些元素在队列中按从大到小排列。队头始终是当前窗口的最大值。

打个比方，你在窗口里维护一个“擂台”，新来的元素直接和擂台上已经排队的人比。如果新来的元素比队伍最后面的一个人还大，那队伍最后面的这个人就永远没机会成为最大值了，因为新元素下标更大，值也更大，它会比旧元素晚离开窗口，同时还比旧元素更强，那旧元素直接淘汰，不用继续留在队列里等结果。

但如果新来的元素比队尾元素小，它仍然有希望。为什么？因为队尾那个大元素可能先滑出窗口，等它走了以后，新元素可能成为窗口内剩余元素的最大值。所以较小的新元素不应该立刻丢掉，而是先排在队尾。

3.2 为什么选双端队列而不是普通队列或栈

普通队列只能从队头出队，从队尾入队。听上去适合“窗口滑动”的出队入队，但我们还需要的操作是：从队尾把比新元素小的老元素删掉。这个操作在普通队列里做不了。

如果使用栈，可以从栈顶弹出元素，但窗口滑动要求从左边淘汰老元素，这一侧的操作栈不支持。所以我们需要一头可以出队、另一头可以入队和出队的数据结构，也就是双端队列，通常叫 deque。

C++ 的 std::deque、Java 的 ArrayDeque、Python 的 collections.deque 都支持在队头和队尾以 O(1) 时间进出。队列里不要直接存元素值，而是存数组下标。因为窗口滑动时判断元素是否过期，靠的是下标区间；只存值的话，你根本不知道这个元素是从哪来的、还能在窗口里待多久。存下标，然后通过数组访问下标拿到值，这是很多新手最容易忽略的一步。

3.3 入队时的淘汰规则：为什么要用 <= 而不是 <

每次处理一个新的数组元素 nums[i]，队列里存的都是下标，我们按 nums[下标] 的值来维护单调性。为了让队列从头到尾递减，入队时要先执行这样一个循环：

当队列不为空，并且 nums[队尾下标] <= nums[i] 时，弹出队尾元素，然后把当前下标 i 从队尾入队。

为什么用 <= 而不是 <？我说一下自己的理解。当新元素的值和队尾元素的值相等时，比如窗口里有两个 5，一个是下标 2，一个是下标 5。下标 2 的 5 会先被滑出窗口，下标 5 的 5 更晚过期，并且在新窗口里它同样能提供最大值 5。既然新元素永远不会比旧元素差，并且活得比旧元素久，那旧元素就没有保留的必要。

如果这里使用 <，也能跑出正确答案，但队列里会留下两个值相同的下标。这会造成队列里存在冗余元素，增加队列长度，极端情况下如果很多相等元素连续出现，队列里会堆一堆相等值的下标，虽然不影响最终结果，但会降低算法的清晰度。所以在简洁的代码里，我推荐使用 <=。

3.4 过期规则：队头下标小于窗口左边界就弹出

队列里的下标从左到右一定是递增的，因为每次新下标 i 都从队尾进，当前循环的 i 一定大于之前入队的下标。所以最早过期的一定是队头那个下标。

当前位置为 i 时，窗口是 nums[i - k + 1] 到 nums[i]，窗口左边界是 i - k + 1。如果队头下标小于 i - k + 1，说明队头对应的元素已经不在窗口范围内了，直接弹出。

这个操作需要在把新元素入队之前做吗？顺序其实很关键，后面我会单独讲。你只要记住：标准流程是“先淘汰过期队头，再淘汰无用队尾，然后入队，最后记录答案”。

4. 代码模板与手把手推演

4.1 三个主流语言版本的模板

先给一份 Python 代码，可读性最强，适合用来理解思路：

python复制from collections import deque

def maxSlidingWindow(nums, k):
    if not nums or k <= 0:
        return []
    
    n = len(nums)
    ans = []
    dq = deque()
    
    for i in range(n):
        # 1. 淘汰已经不在当前窗口中的队头元素
        if dq and dq[0] < i - k + 1:
            dq.popleft()
        
        # 2. 保持队列从头到尾递减，淘汰不可能成为最大值的队尾元素
        while dq and nums[dq[-1]] <= nums[i]:
            dq.pop()
        
        # 3. 当前元素下标入队
        dq.append(i)
        
        # 4. 当窗口成形后，记录当前窗口最大值
        if i >= k - 1:
            ans.append(nums[dq[0]])
    
    return ans

再给一份 C++ 版本，刷题时比较常用：

cpp复制class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        int n = nums.size();
        vector<int> ans;
        deque<int> dq;
        
        for (int i = 0; i < n; ++i) {
            while (!dq.empty() && dq.front() < i - k + 1) {
                dq.pop_front();
            }
            
            while (!dq.empty() && nums[dq.back()] <= nums[i]) {
                dq.pop_back();
            }
            
            dq.push_back(i);
            
            if (i >= k - 1) {
                ans.push_back(nums[dq.front()]);
            }
        }
        
        return ans;
    }
};

Java 版本也补一份，因为剑指Offer的读者里用 Java 的人非常多：

java复制class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if (nums == null || nums.length == 0 || k <= 0) {
            return new int[0];
        }
        int n = nums.length;
        int[] ans = new int[n - k + 1];
        Deque<Integer> dq = new ArrayDeque<>();
        int idx = 0;
        
        for (int i = 0; i < n; i++) {
            while (!dq.isEmpty() && dq.peekFirst() < i - k + 1) {
                dq.pollFirst();
            }
            
            while (!dq.isEmpty() && nums[dq.peekLast()] <= nums[i]) {
                dq.pollLast();
            }
            
            dq.offerLast(i);
            
            if (i >= k - 1) {
                ans[idx++] = nums[dq.peekFirst()];
            }
        }
        
        return ans;
    }
}

三个版本的逻辑完全一样，只是容器 API 不同。你不需要把它们全部背下来，只要吃透一个版本，语言之间的迁移成本很低。

4.2 拿一串数据手动走一遍队列变化

用前面那个例子：nums = [1, 3, -1, -3, 5, 3, 6, 7]，k = 3。我们从头到尾模拟一下队列里到底发生了什么，这样你就不会觉得代码是在背魔法。

• i = 0，nums[0] = 1。队列为空，直接入队，dq = [0]。此时 i < 2，不记录，因为第一个完整窗口还没形成。
• i = 1，nums[1] = 3。队头 0 还在窗口内，无需淘汰。再看队尾 nums[dq.back()] = nums[0] = 1 <= 3，所以把 0 弹出。入队 1，dq = [1]。此时窗口依然不完整，不记录。
• i = 2，nums[2] = -1。队头 1 还在窗口内。队尾值是 3，3 不小于 -1，所以 -1 直接入队，dq = [1, 2]。i >= 2，记录 nums[dq.front()] = nums[1] = 3。第一个窗口最大值是 3，正确。
• i = 3，nums[3] = -3，当前窗口范围是下标 [1, 3]。队头是 1，1 < 1 吗？不小于，所以 1 仍然有效。队尾值 -1 不大于 -3，-3 入队，dq = [1, 2, 3]，记录最大值还是 3。
• i = 4，nums[4] = 5。当前窗口范围是下标 [2, 4]。队头是 1，1 < 2，说明下标 1 的 3 已经移出窗口，弹出。dq = [2, 3]。现在队尾是 3，nums[3] = -3 <= 5，弹出；再看队尾是 2，nums[2] = -1 <= 5，也弹出。dq 空，把 4 入队，dq = [4]，记录 nums[4] = 5。窗口 [-1, -3, 5] 最大值是 5，正确。
• i = 5，nums[5] = 3。队头 4 当前有效，队尾 3 与 5 比较：nums[4] = 5 <= 3 不成立，直接入队 5，dq = [4, 5]，记录 5。窗口 [ -3, 5, 3 ] 最大值是 5，正确。
• i = 6，nums[6] = 6。队头 4 有效。队尾 3 <= 6，弹出 5；队尾 nums[4] = 5 <= 6，弹出 4。入队 6，dq = [6]，记录 6。窗口 [5, 3, 6] 最大值 6。
• i = 7，nums[7] = 7。队头 6 有效。队尾 6 <= 7，弹出 6。入队 7，dq = [7]，记录 7。窗口 [3, 6, 7] 最大值 7。

最终答案是 [3, 3, 5, 5, 6, 7]。你会发现队列中的元素始终是递减的，队头就是答案。整个过程中，没有哪个元素被访问超过常数次。

4.3 模板里最容易写错的地方

这套模板代码很短，但细节非常多。我见过不少人在面试时出现下面的错误：

第一，忘记先淘汰队头过期元素。如果你先处理队尾、再处理过期，极有可能在某个时刻把一个已经滑出窗口的下标留到队头，导致记录答案时取到旧值。顺序最好固定为：先淘汰过期队头，再维护单调队尾，再入队，最后记录答案。

第二，出队判断写成 dq.front() <= i - k。这个左边界要仔细推导。窗口包含的是从 i - k + 1 到 i，所以下标等于 i - k + 1 的元素仍然有效。只有下标 < i - k + 1 才失效。如果你用了 <=，会把窗口边界上那个本应有效的元素也弹掉，答案就会出错。

第三，在 nums[dq.back()] <= nums[i] 中写反符号，把单调递减写成了单调递增。写完后可以自己用几个例子在纸上跑一下，确认队头是不是最大值。

第四，窗口尚未形成就开始记录答案的边界。一定要用 if (i >= k - 1) 判断当前是否已经有完整窗口。k = 1 时，i 从 0 开始就满足条件，每个元素单独作为窗口，结果就是原数组本身；k 很大时，前 k - 1 个元素都不能进答案数组。

5. 复杂度、证明与面试官的高频追问

5.1 为什么整体复杂度是 O(n)

这个问题面试官几乎必问。虽然代码里有一个内层 while 循环负责弹出元素，看起来像循环套循环，但我们要分析的是整个算法执行过程中所有元素的总操作次数。

每个元素下标最多入队一次。它只有在被后来的更大元素淘汰，或者因为窗口滑动过期时才会出队，加起来出队也最多一次。所以每个元素贡献的入队、出队操作都是 O(1) 次。整个 for 循环执行 n 次，所有 while 循环里弹出操作的总次数不超过 n。所以时间复杂度是 O(n)。

这个过程叫“摊还分析”。你不应该笼统地说“内层循环最坏 O(k)，所以复杂度是 O(nk)”，因为在单调队列里，内层循环的代价可以被前面的入队操作抵消，整体是线性的。

5.2 和优先队列、堆解法的对比

面试时如果能主动说出“除了单调队列，还可以用最大堆”，会显得你对多种解法都有了解。

堆解法的思路是：维护一个大顶堆，堆里存两个信息，元素值和下标。每次窗口移动时，加入新元素；在取最大值前，循环弹出那些下标已经滑出窗口的堆顶元素，剩下的堆顶就是当前窗口最大值。它的实现比单调队列更直观，但时间复杂度是 O(n log n)，因为堆的插入、删除复杂度都是 O(log n)，而且堆里会堆压一些已经过期但还没弹出的历史元素，空间占用更大。

这三种解法可以简单对比：

单调队列在理论和实际跑分上都是最优的，也是面试官最想看到的答案。但能讲出堆解法，说明你不是只会背单调队列模板，而是真分析过不同数据结构的取舍。

5.3 队列空间到底算 O(k) 还是 O(n)

在不额外统计答案数组的情况下，双端队列里最多有多少个元素？它最多不会超过窗口大小 k，因为在任意时刻，队列里的下标都属于当前窗口或更早的一些元素，而真正尚未被淘汰且仍在窗口内的下标，最多只有 k 个。所以算法本身的额外空间是 O(k)，更严谨一点可以说 O(min(n, k))。

但如果使用的是优先队列，老旧元素不会立刻被删除，堆里可能积压大量下标，最坏情况下堆中同时存在 n 个元素，所以空间是 O(n)。这也是优先队列解法的一个短板。

6. 边界用例与隐蔽 Bug，都是容易在实际代码里踩的坑

6.1 空数组、窗口大小为 0、窗口比数组还长

先说空数组和 k = 0。空数组没有任何窗口，返回空数组是符合直觉的。窗口大小如果是 0，从数学上也不存在有效窗口，最好在函数开头就防御性返回空，避免后面做 i - k + 1 时出现负数造成混乱。

窗口比数组长呢？实际题目一般会约束 k <= nums.length，但如果不加约束，你返回空数组或那个数组中的最大值都意义不大。我建议在代码开头对非法输入先返回空数组。这种习惯在面试里非常加分，因为面试官喜欢看边界处理意识。

6.2 k = 1 和 k = n 的极端情况

k = 1 时，每个窗口只有一个元素，窗口最大值就是该元素本身，答案就是整个原数组。用单调队列代码跑起来也不会有问题，因为每次进入循环后，先淘汰掉上一个窗口的队头，再入队当前元素，然后立刻记录。

k = n 时，整个数组只有一个窗口。代码会从 i = 0 处理到 i = n - 1，在前 n - 1 次循环一直不记录，最后一次才把整个数组的最大值加入答案。你可以试着用 [1, 3, 2] 和 k = 3 手动走一遍，确认能正确返回 [3]。

6.3 大量相等元素时的正确性

如果数组全是同一个数字，比如 [5, 5, 5, 5]，k = 2，结果应该是 [5, 5, 5]。

用我们推荐的使用 <= 的写法，新元素会把旧的相等元素弹出队列，队列里永远只有一个 5，但它的下标会不断更新成最新的位置，这样就保证这个 5 不会因为旧下标过期而提前消失。如果用 <，虽然队列里会短暂保有多个相等下标，但取出的值还是 5，代码仍能通过。真正危险的是写反符号，比如写成了 nums[dq.back()] < nums[i] 且你的本意是单调递减，其实这是允许的，会有点冗余，但不会错。只有当队尾小于新元素时弹出，这其实等价于严格递减，但最大值一样，因为相等的旧值是最大时，新值也相等，仍然最大。所以正确。但冗余可能引起不必要的复杂度，虽然也是 O(n)，但可读性差。面试时我们没必要留这种隐患。

6.4 下标计算错误是翻车的重灾区

很多人喜欢用条件 while (!dq.empty() && dq.front() <= i - k)，觉得窗口右边界是 i，左边界应该就是 i - k，其实不对。当前窗口其实是从 i - k + 1 到 i，左边界不是 i - k。比如 i=2，k=3，当前窗口应该是下标 0、1、2，左边界是 0；如果你写成 i - k = -1，那么队头下标 0 不会被淘汰，这还能接受。再比如 i=3，k=3，当前窗口是 1、2、3，左边界是 1；如果写成 dq.front() <= i - k，也就是 <= 0，那么下标 1 不会被淘汰，但下标 1 确实该在窗口里，所以没有错。可一旦遇到下标正好等于 i-k+1 的情况？如果用 <= left，会误删 left。所以正确写法必须是 dq.front() < i - k + 1，或者等价地 dq.front() <= i - k 吗？我们重新算一下：left = i - k + 1。如果 front < left，等价于 front <= i - k。所以 dq.front() <= i - k 这个写法其实是和 `front < i