张云雷宝宝这道题我刷了不下五遍，每次面试前还是会翻出来看一眼。不是因为它难，恰恰是因为它简单到能一眼看出暴力解，又巧妙到值得反复咀嚼——剑指offer第64题“滑动窗口的最大值”，表面上是求一个数组里所有固定长度窗口的最大值，实际上是考察对数据结构特性的理解深度。面试官爱考这道题，是因为它能在一道题里同时试探出你的基础编码能力、复杂度分析能力和现场推导能力。
题目本身不复杂：给定一个数组和滑动窗口大小k，要求输出每个窗口内的最大值。比如数组[1,3,-1,-3,5,3,6,7]，k=3，结果就是[3,3,5,5,6,7]。但如果只会暴力扫描，k接近n时复杂度直接来到O(nk)，在数据量上来之后就是灾难。所以这篇文章会把整道题从题目本质、暴力解法、优化思路到双端队列的完整实现一层层拆开来讲，最后再分享几个我在实际刷题和面试复盘里总结的细节与坑。
1. 题目定位与整体解题思路拆解
1.1 这道题到底在考什么
先说结论：这道题在考两件事。第一件是你能不能识别出这是一个“滑动窗口”问题，第二件是你能不能想到用双端队列来维护窗口内的候选最大值集合。第一件事决定你能不能写出正确的解，第二件事决定你能不能写出高效的解。
滑动窗口这个概念在算法题里出现频率极高，它本质上是一个“固定长度的子数组连续右移”的过程。每移动一步，窗口丢掉最左边的元素，纳入一个新元素，然后需要立即得出当前窗口的某个统计量（最大值、最小值、平均值、中位数等）。本题要的是最大值。
如果你对这个场景敏感，应该立刻意识到：窗口向右移动的过程中，相邻两个窗口之间的重叠部分长达k-1个元素。换句话说，每次滑动其实只有两个元素发生变化——一个被移除，一个被加入。如果每次都重新扫描整个窗口，那就白白浪费了重叠部分的计算。这就像你在一个班级里记录连续三天的考试成绩最高分，明明前两天的最高分还在，只因为最后一天换了个新同学就把前两天的成绩全部重新算一遍，显然是低效的。
1.2 从暴力解到高效解的演进路线
暴力解法的逻辑最简单：枚举每个窗口的起始位置，然后在内层循环遍历当前窗口内的k个元素，找出最大值放入结果数组。
cpp复制vector<int> maxSlidingWindow(vector<int>& nums, int k) {
vector<int> result;
for (int i = 0; i + k <= nums.size(); i++) {
int maxVal = nums[i];
for (int j = i + 1; j < i + k; j++) {
maxVal = max(maxVal, nums[j]);
}
result.push_back(maxVal);
}
return result;
}
这个解法的代码只有十行左右，正确性一目了然，时间复杂度是O(nk)。当n和k都在10^5级别时，这个复杂度基本没法用。所以必须寻找O(n)的方案。
O(n)方案的关键在于想明白一件事：窗口滑动的过程中，我们需要一个数据结构，能够同时支持三个操作：快速获取当前最大值、在窗口左端移除元素时快速更新最大值、在窗口右端加入新元素时快速更新最大值。普通的队列做不到，因为队列只能从队尾入、队头出，出队后如果出队元素恰好是最大值，你无法立刻知道下一个最大值是谁。Heap也不行，因为堆删除任意元素不是O(1)的。真正合适的工具是双端队列，它在队头和队尾都能O(1)地进出，并且如果我们维护队列内部元素的单调性，就能让队头始终是窗口内的最大值。
这个思路就是这道题的核心：用双端队列维护一个单调递减的候选最大值序列。后面我会完整展开。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 双端队列方案：为什么它是最优解
2.1 数据结构选型：为什么选deque而不是堆或队列
先聊聊数据结构选型的逻辑。很多人第一反应是用最大堆：每次窗口滑动，把新元素丢进堆里，然后弹出不在窗口范围内的元素，堆顶就是最大值。这个思路没问题，但有两个隐患。第一，堆的插入和删除都是O(log k)，整体复杂度是O(n log k)，虽然能过，但常数偏大。第二，你无法惰性删除堆中任意一个过期元素，只能在堆顶恰好是过期元素时才把它弹出，这会导致堆里堆积大量“已经不在窗口内”的元素，堆的大小不可控。我曾经在实际测试中遇到过堆里堆积了大量过期元素导致内存占用偏高的情况，虽然不至于出错，但代码写起来要格外小心。
普通队列更不行，因为它只能队头出队、队尾入队，获取最大值需要遍历整个队列。而双端队列（deque）的特性是两端都能O(1)进出，再配合上“单调性”这个约束，就能把最大值维护在队头，同时保证队列里每个元素都“有资格”在未来成为最大值。
deque还有一个额外好处：删除过期元素时，只需要检查队头，因为根据我们维护的单调性，队头的索引一定是最老的（这个说法在实现时要留意，队列里存的索引是单调递增的，队头索引最小）。这给我们提供了一条清晰的维护路径：每次窗口滑动时，先检查队头是否已经滑出窗口，是则弹出；然后把新元素从队尾加入，加入前弹出所有比它小的元素；最后队头就是当前窗口最大值。
2.2 单调队列的核心思想：淘汰“永远不可能成为最大值”的元素
很多人卡在这道题上，关键是没想明白“为什么可以在尾部弹出比新元素小的旧元素”。这里有个重要的观察：假设新元素是nums[j]，它在窗口中的位置比队列尾部那些元素都靠右，值又比它们大。那么从新元素进入窗口的那一刻起，直到那些旧元素滑出窗口，新元素都会一直留在窗口里，并且数值始终比它们大。也就是说，只要新元素还在窗口内，这些更小且更靠左的旧元素就永远不会成为窗口最大值。
这个推理非常像“劣币驱逐良币”的反向操作：新来的更强者直接把所有弱于自己的旧元素全部“干掉”，因为它们已经失去了未来的竞争资格。但如果队列里有一个比你大的元素在你左边，你干不掉它，只能老老实实待在它后面，等它先滑出窗口。这个逻辑可以用一句话概括——队列里保存的，是从当前窗口往后看，每个“未来可能成为最大值”的候选元素。
举个例子，窗口内目前是[5,3,1]，新元素是4。从左向右排列的5、3、1中，1和3都会被4淘汰，队列变为[5,4]。为什么1和3没有未来了？因为4比它们大、又比它们靠右，在4存活期间它们永远没机会出头。而5比4大且更靠左，所以5保留。等到5滑出窗口后，4顺理成章成为新的最大值。这就是单调队列的“远见”所在：它不保存所有元素，只保存有未来的候选者。
2.3 窗口移动时如何维护队列的完整状态
完整维护流程分为三步。第一步，处理队头过期元素。窗口左边界向右移动时，某些元素已经滑出窗口，需要把它们从队头弹出。判断标准是：deque中存放的是元素下标，如果队头下标等于当前窗口左边界的前一个位置，说明它已经不在窗口内。实际代码中一般用if (deque.front() == i - k)来判断，因为窗口每次只滑一格，所以最多只有一个元素会过期。
第二步，处理新元素入队。从队尾开始，把所有比新元素小的元素全部弹出，然后新元素下标入队。这步是单调性的核心，也是与普通队列最大的区别。
第三步，记录当前窗口最大值。当窗口形成完整大小（即遍历到的下标i >= k-1）时，队头下标对应的元素就是当前窗口最大值，把它加入结果数组。
三步走下来，每个元素最多入队一次、出队一次，总操作次数是O(n)，均摊到每一步就是O(1)的复杂度。这也是整道题的精华所在——把暴力解法里重复扫描窗口的O(k)操作，通过数据结构的维护摊销成了O(1)。
3. 完整实现与代码细节解析
3.1 C++ 实现与关键代码注释
用C++写这道题时，我的习惯是直接使用std::deque<int>存放元素下标。很多初学者会在这里踩坑：队列里存的是值，而不是下标。存值会带来两个问题：一是无法判断元素是否过期，二是无法处理重复值（虽然存值也可以处理，但要额外记录位置信息，不如直接存下标干净利落）。所以第一原则：队列里存下标。
cpp复制class Solution {
public:
vector<int> maxSlidingWindow(vector<int>& nums, int k) {
vector<int> result;
deque<int> dq; // 存下标，维护单调递减序列
for (int i = 0; i < nums.size(); i++) {
// 1. 移除窗口外的元素（队头过期检查）
if (!dq.empty() && dq.front() == i - k) {
dq.pop_front();
}
// 2. 新元素入队前，淘汰队尾所有比它小的元素
while (!dq.empty() && nums[dq.back()] <= nums[i]) {
dq.pop_back();
}
dq.push_back(i);
// 3. 窗口形成后，记录最大值
if (i >= k - 1) {
result.push_back(nums[dq.front()]);
}
}
return result;
}
};
有个细节值得注意：第2步的淘汰条件是<=而不是<。这意味着当遇到相等元素时，新元素会把旧元素挤掉。为什么选<=？因为对于相等的两个值，更靠右的那个在窗口里存活时间更久，用更靠右的替代更靠左的，显然是更优的选择。如果写成<，队列里可能同时存在两个相等元素，不但浪费空间，还会让队头元素过期判断变复杂。用<=就能保证队列中各元素下标严格递增、值严格递减。
还有一个细节：第1步的过期判断用的是== i - k而不是<= i - k。原因在于窗口每次只滑动一格，每轮最多只有一个元素移出窗口，所以判断队头元素是否恰好等于窗口左边界的前一个位置就足够了。当然写成while循环配合<=判断也没有错，但从逻辑严谨性上讲，单次比较就够了。
3.2 Java 版实现与说明
Java版本几乎可以照搬C++的逻辑，把deque换成ArrayDeque即可。唯一要注意的是ArrayDeque不允许存放null元素，但这里存的是int的包装类Integer的下标，不会出现null，所以没问题。
java复制class Solution {
public int[] maxSlidingWindow(int[] nums, int k) {
int n = nums.length;
int[] result = new int[n - k + 1];
Deque<Integer> deque = new ArrayDeque<>();
for (int i = 0; i < n; i++) {
// 移除不在窗口内的队头
if (!deque.isEmpty() && deque.peekFirst() == i - k) {
deque.pollFirst();
}
// 淘汰队尾较小元素
while (!deque.isEmpty() && nums[deque.peekLast()] <= nums[i]) {
deque.pollLast();
}
deque.offerLast(i);
// 记录窗口最大值
if (i >= k - 1) {
result[i - k + 1] = nums[deque.peekFirst()];
}
}
return result;
}
}
Java面试时，如果你能流畅解释peekFirst、pollLast这些方法对应的数据操作，并说清楚为什么时间复杂度是均摊O(1)，面试官往往会满意地点点头。这里还建议你掌握一个细节：ArrayDeque底层是循环数组，扩容时会有一次数组复制，但由于扩容次数是对数级别的，均摊下来依然是O(1)。
3.3 Python 版实现与列表模拟双端队列
Python用collections.deque最方便，但如果你不想引入额外模块，也可以用普通列表模拟双端队列，只是队头操作的复杂度会变成O(n)。这里推荐直接用collections.deque，配合索引存储。
python复制from collections import deque
def maxSlidingWindow(nums, k):
result = []
dq = deque() # 存下标
for i in range(len(nums)):
# 队头过期
if dq and dq[0] == i - k:
dq.popleft()
# 保持单调递减，新元素大则淘汰队尾
while dq and nums[dq[-1]] <= nums[i]:
dq.pop()
dq.append(i)
# 窗口形成后记录最大值
if i >= k - 1:
result.append(nums[dq[0]])
return result
Python写法的核心逻辑和各语言一致。需要注意的一点是，Python的deque在按下标索引时是O(n)的操作，但这里的操作是对dq[0]取队头，是O(1)的，所以性能没问题。如果你需要频繁按下标访问deque内部元素，就要小心了，那个不是O(1)。
4. 手工推演：用具体案例走一遍完整流程
4.1 以数组 [1,3,-1,-3,5,3,6,7]，k=3 为例
这个案例就是剑指offer原题的例子，非常经典，我建议每个读者都亲手推一遍。
初始化：i=0，队列为空。直接入队，deque = [0]（对应值1）。i < k-1，不记录结果。
i=1，元素3。队头0是否等于1-3=-2？不是，跳过过期处理。队尾元素0对应值1，1 <= 3，弹出。deque变为空，下标1入队，deque = [1]（对应值3）。i < k-1，不记录结果。
i=2，元素-1。队头1是否等于2-3=-1？不是。队尾元素1对应值3，3 > -1，不弹出。下标2入队，deque = [1,2]（对应值3,-1）。i >= k-1，记录nums[dq[0]]=3，结果[3]。
i=3，元素-3。队头1是否等于3-3=0？不是。队尾2对应-1，-1 > -3，不弹出。下标3入队，deque = [1,2,3]（对应3,-1,-3）。记录3，结果[3,3]。
i=4，元素5。队头1是否等于4-3=1？是。弹出1，deque = [2,3]。队尾3对应-3，-3 <= 5，弹出；队尾2对应-1，-1 <= 5，弹出。deque为空，下标4入队，deque = [4]（对应5）。记录5，结果[3,3,5]。
i=5，元素3。队头4是否等于5-3=2？不是。队尾4对应5，5 > 3，不弹出。下标5入队，deque = [4,5]（对应5,3）。记录5，结果[3,3,5,5]。
i=6，元素6。队头4是否等于6-3=3？不是。队尾5对应3，3 <= 6，弹出；队尾4对应5，5 <= 6，弹出。deque为空，下标6入队，deque = [6]（对应6）。记录6，结果[3,3,5,5,6]。
i=7，元素7。队头6是否等于7-3=4？不是。队尾6对应6，6 <= 7，弹出。下标7入队，deque = [7]（对应7）。记录7，结果[3,3,5,5,6,7]。
完整的推演过程就是上面这样。你可能会注意到，在i=4时，队头1恰好等于i-k=1，说明这个下标已经滑出了当前窗口，因此被弹出。这就是“过期检查”的时机。这种“推演一次之后，代码逻辑就刻在脑子里了”的感觉，非常值得体验一次。
4.2 边界条件推演：窗口大小为1和窗口大小等于数组长度
接着做两个极端的推演。
k=1时，每个窗口只有一个元素，最大值就是该元素本身。按照算法流程：每轮新元素入队前，会弹出队尾所有小于等于新元素的元素。由于上一轮窗口内唯一的元素下标必然等于i-1，而i-1 == i-1，所以它在当前轮会被过期检查直接弹出。然后新元素入队，队头就是它自己，记录结果。结果数组正好等于原数组。这个推演验证了算法在最小窗口下不会出错。
k=n时，整个数组只有一个窗口。此时窗口从未真正滑动过，所有过期检查条件dq.front() == i - k永远不会触发（因为i-k始终小于0或等于0时我们已经处理完了）。整个处理过程等价于“用一个单调递减队列从左到右扫一遍，最后队头就是最大元素”。结果数组只有一个元素，恰好是数组全局最大值。例如[3,1,4,1,5,9,2,6]，k=8，最终结果就是9。这个推演说明算法对窗口大小等于整个数组的情况也天然兼容。
5. 常见问题与易错点排查
5.1 队列里到底存值还是存下标
这是初学者最常问的问题，也是动手写代码时暴露得最明显的问题。如果存值，当队头元素过期时，你无法判断它是否还在当前窗口内，因为你不知道它的位置信息。当然你可以额外存一个pair<value, index>，但既然标准解法直接用下标，为什么还要绕弯路呢？直接存下标，取最大值时用nums[dq.front()]，判断过期时用dq.front() == i - k，所有操作都顺畅无比。我见过不少人在面试时因为存值导致无法判断过期，从而写出一堆丑陋的补救代码，最后被迫重写。所以这里再次强调：队列里存的是下标。
5.2 队头过期判断用==还是<=
先说结论：用==更精确，但<=配合while循环也不会错。原因在于窗口滑动是单步进行的，每轮最多有一个元素滑出窗口，且滑出的一定是上一轮队头元素（如果它还在队列里）。用== i - k判断是临界的精确判断。如果写成while (!dq.empty() && dq.front() <= i - k)，也能工作，但多做了不必要的检查。两种写法在结果上完全一致，面试时能说出==和<=的区别，会显得你对细节有清晰的掌控力。
有一个隐藏边界：当k=1时，i-k恰好等于上一个元素的下标，所以每一轮队头都会过期。用==判断可以准确弹出，结果正确。如果k是0或者负数，题目本身就不合法，一般不用考虑。
5.3 为什么新元素入队前要弹出所有更小或相等的元素
这个问题我在前面原理部分已经详细讲过，但这里再多说一句：这是整个算法从暴力进化为线性的关键一步。如果不做这一步，队列会退化成一个普通队列，最大值无法直接获取。而做了这一步之后，队列内元素从队头到队尾是严格单调递减的，队头永远是窗口最大值的候选者。这步操作还有一个额外好处：队列长度永远不会超过k+1，空间占用是O(k)。
来个具体对比：假设当前窗口是[2,1,5]，队列中存的是[2,1]，新元素5入队时会把1和2全部弹出，队列变成[5]。如果1和2不被弹出，那么窗口滑到[1,5,3]时，队列里的2和1都已经过时，还得靠过期判断逐一弹出，既浪费操作又让逻辑更复杂。在队尾主动淘汰，本质上是在元素入队前就处理掉“未来一定没用”的垃圾数据，属于典型的惰性删除与主动淘汰的取舍。
5.4 在C++中deque与vector的选择
有些答案用vector模拟队列，通过维护一个头指针而不是真正弹出队头。这种写法在C++里也能跑，因为vector的随机访问速度通常比deque快。但要注意，如果直接用erase(begin())删除队头，复杂度是O(n)，会让整体算法退化为O(n²)。所以如果非要用vector，正确的做法是维护一个head指针指向逻辑队头，每次过期时head++而不真正删除元素。不过，用标准库deque依然是最稳妥、最清晰的选择，它在两端操作上都是O(1)且底层实现是分段连续的，缓存友好度也不差。
5.5 对重复元素的处理
当数组中出现大量重复值时，例如[5,5,5,5,5]，k=3，整个处理流程是什么样的？i=0，5入队；i=1，新元素5入队前，由于nums[dq.back()] <= nums[i]，即5 <= 5成立，旧5被弹出，新5入队；i=2同理。最终队列里永远只有一个下标，指向最新遇到的5，结果数组全是5。这个处理是正确的，但有个细节值得注意：我们用新5替换旧5，意味着当窗口滑动时，队尾元素的“年龄”不会太老，从而减少了过期检查的触发频率。这个微妙的优化就是<=带来的。如果写成<，队列中会积累大量等值元素，虽然最终结果依然正确，但队列长度会变长，过期弹出操作也会增多。
6. 滑动窗口思想的延伸场景与后续扩展
6.1 求滑动窗口的最小值/中位数/均值等问题
滑动窗口的题目是一个家族，最大值只是其中最经典的一个。想通“队列存下标 + 单调性”这个套路后，很多题目都能触类旁通。
滑动窗口最小值就是镜像操作：把单调递减换成单调递增即可。逻辑完全对称，代码几乎一改<=为>=。我在刷题时经常把这两道题放在一起练习，效果很好。滑动窗口均值则更简单，用一个前缀和数组或者直接维护一个窗口中元素的累积和，每步加新减旧，O(1)就能得到均值。但如果窗口大小k可以变化，或者要动态查询窗口内的分位数，那就得用“对顶堆”或者“树状数组+二分”这类更复杂的数据结构了。
值得一提的是，这道题还有一个变体：求每个窗口的最大值和最小值的差。其实只要同时维护一个单调递减队列和一个单调递增队列，分别求最大值和最小值，然后相减即可。我在刷P5724“求极差/最大跨度值”这类题目时，就发现这个思路是直接能套用的。
6.2 双端队列思路在业务系统中的应用
很多业务场景看起来跟算法题八竿子打不着，其实底层就是滑动窗口。
最常见的例子是限流。在网关或接口层做限流时，滑动窗口算法会记录最近一个时间窗口内的请求次数，如果超过阈值就拒绝新请求。与固定窗口相比，滑动窗口能更平滑地控制请求速率，避免在窗口边界出现瞬间流量尖峰。用Redis的ZSET或简单的环形数组都能实现，但核心思想依然是“维护一个窗口内的候选集合并快速判断是否超限”——与本题的维护思路一脉相承。
另一个例子是时序数据处理中的滑动窗口滤波。当传感器数据流进来时，我们需要对最近N个数据点做平均或加权平均，以消除噪声。如果用数组存储这N个点，每次窗口移动都需要重复求和；如果用一个队列加上一个累积和变量，就能实现O(1)的滤波计算。我在实际工作中处理传感器数据时，就经常用这种“滑动窗口”的思路去简化计算，虽然场景比算法题更工程化，但模式完全一致。
6.3 从面试角度看这道题的晋级路线
最后聊一下面试官视角。这道题在剑指offer里属于“考察数据结构与优化能力”的中等难度题。面试官通常不会只满足于你会写代码，他们期待的答题路径是这样的：
第一层，能写出暴力解法并正确分析时间复杂度O(nk)。第二层，能想到用堆优化到O(n log k)，并指出堆的缺陷（无法快速删除任意元素、空间可能膨胀）。第三层，能想到用双端队列维护单调递减序列，并解释清楚为什么每个元素最多入队出队一次，均摊O(1)。如果你能在第三层基础上，把过期判断、等值淘汰这些细节讲透，再顺手提一句“这个问题还可以扩展到滑动窗口最小值或滑动窗口中位数”，基本就能在这个题上拿到满分了。
我自己刷题复盘时的体会是：这道题最重要的不是背代码，而是把“单调队列为什么是对的”用大白话讲给一个完全不懂的人听。如果能讲清楚“新元素为什么能淘汰左边所有比它小的元素”，那你离真正理解这个套路就不远了。
6.4 一道练习题：换一个条件，试试能不能秒杀
这里留一道变体题练手：给定一个整数数组和一个窗口大小k，请输出所有窗口内的最小值。看似只是把最大值改成最小值，但如果你动手写一遍，会发现要把单调递减队列改为单调递增队列，同时还要处理好等值元素的处理策略。写完之后再问自己一个问题：如果窗口大小k不是一个固定值，而是随机变化的，单调队列还适用吗？如果不能，你会用什么数据结构来替代？
这种“换一个条件再推演一遍”的练习方式，比单纯刷十道新题更能加深对滑动窗口模型的理解。至少我是这么练的，效果很不错。