目录
[1. 思路分析](#1. 思路分析)
[2. 代码实现（C++）](#2. 代码实现（C++）)
[3. 复杂度分析](#3. 复杂度分析)
[4. 问题核心：为何暴力法低效？](#4. 问题核心：为何暴力法低效？)
[1. 核心思路：用 "单调递减队列" 维护窗口信息](#1. 核心思路：用 “单调递减队列” 维护窗口信息)
[2. 单调队列的工作流程（示例 1）](#2. 单调队列的工作流程（示例 1）)
[步骤 1：i=0（元素 1）](#步骤 1：i=0（元素 1）)
[步骤 2：i=1（元素 3）](#步骤 2：i=1（元素 3）)
[步骤 3：i=2（元素 - 1，首次形成窗口）](#步骤 3：i=2（元素 - 1，首次形成窗口）)
[步骤 4：i=3（元素 - 3）](#步骤 4：i=3（元素 - 3）)
[步骤 5：i=4（元素 5）](#步骤 5：i=4（元素 5）)
[3. 完整代码实现（C++）](#3. 完整代码实现（C++）)
[4. 关键步骤解析](#4. 关键步骤解析)
[（1）为何用 "索引" 而非 "值"？](#（1）为何用 “索引” 而非 “值”？)
[（2）为何 "从队尾剔除小于当前元素的索引"？](#（2）为何 “从队尾剔除小于当前元素的索引”？)
[（3）为何队列是 "单调递减" 而非 "单调递增"？](#（3）为何队列是 “单调递减” 而非 “单调递增”？)
[5. 复杂度分析](#5. 复杂度分析)
[1. 情况 1：k=1](#1. 情况 1：k=1)
[2. 情况 2：k=n（窗口覆盖整个数组）](#2. 情况 2：k=n（窗口覆盖整个数组）)
[3. 情况 3：nums 为空或 k=0](#3. 情况 3：nums 为空或 k=0)
一、问题描述：明确需求
给你一个整数数组 nums，有一个大小为 k的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。
返回 滑动窗口中的最大值。
传送门：滑动窗口最大值
示例 1：
输入：nums = [1,3,-1,-3,5,3,6,7], k = 3
输出：[3,3,5,5,6,7]
解释：
滑动窗口的位置 最大值
--------------- -----
[1 3 -1] -3 5 3 6 7 3
1 [3 -1 -3] 5 3 6 7 3
1 3 [-1 -3 5] 3 6 7 5
1 3 -1 [-3 5 3] 6 7 5
1 3 -1 -3 [5 3 6] 7 6
1 3 -1 -3 5 [3 6 7] 7示例 2：
输入：nums = [1], k = 1
输出：[1]二、入门解法：暴力枚举
1. 思路分析
最直接的想法是：遍历所有可能的窗口，每个窗口内遍历k个元素找最大值。具体步骤：
- 滑动窗口的起始位置
left范围是[0, n-k]（n为数组长度） - 对每个
left，计算窗口内[left, left+k-1]的最大值 - 将所有最大值收集到结果数组中
2. 代码实现（C++）
cpp
vector<int> maxSlidingWindow(vector<int>& nums, int k) {
vector<int> res;
int n = nums.size();
if (n == 0 || k == 0) return res;
// 遍历所有窗口的起始位置
for (int left = 0; left <= n - k; left++) {
int max_val = nums[left];
// 遍历窗口内元素找最大值
for (int right = left + 1; right < left + k; right++) {
max_val = max(max_val, nums[right]);
}
res.push_back(max_val);
}
return res;
}3. 复杂度分析
- 时间复杂度 ：
O(n*k)。外层循环n-k+1次，内层循环每次k次，当n和k都很大时（如n=1e5），会超时。 - 空间复杂度 ：
O(1)（除结果数组外无额外空间）。
4. 问题核心：为何暴力法低效？
暴力法的痛点在于重复计算 ：窗口右移时，仅新增 1 个元素、删除 1 个元素，但我们却重新遍历k个元素找最大值。优化方向：保存窗口内的 "有用信息"，避免重复比较------ 我们只需要知道窗口内的最大值，不需要关心其他元素的具体大小，除非它们可能成为后续窗口的最大值。
三、进阶优化：单调队列（最优解法）
1. 核心思路：用 "单调递减队列" 维护窗口信息
我们需要一个数据结构，满足以下需求：
- 快速获取当前窗口的最大值（
O(1)） - 窗口右移时，高效删除 "过期元素"（不在当前窗口内的元素）
- 窗口右移时，高效添加 "新元素"，并剔除不可能成为后续最大值的元素
单调递减队列恰好满足这些需求：
- 队列内元素的索引对应的数值严格递减（队首是当前窗口最大值）
- 队列中存储的是 "元素索引" 而非 "元素值"，方便判断元素是否在当前窗口内
2. 单调队列的工作流程（示例 1）
以nums = [1,3,-1,-3,5,3,6,7]，k=3为例，逐步拆解每一步操作：
初始化
- 单调队列
dq（存储索引），结果数组res - 遍历数组索引
i（从 0 开始）
步骤 1：i=0（元素 1）
- 队列空，直接加入索引 0 →
dq = [0] - 未形成窗口（
i < k-1=2），不记录结果
步骤 2：i=1（元素 3）
- 剔除队尾小于当前元素的索引 ：队尾是 0（值 1 < 3），弹出 →
dq为空 - 加入当前索引 1 →
dq = [1] - 未形成窗口，不记录结果
步骤 3：i=2（元素 - 1，首次形成窗口）
- 剔除队尾小于当前元素的索引：队尾是 1（值 3 > -1），不弹出
- 加入当前索引 2 →
dq = [1,2] - 形成窗口（
i >=2），队首 1 对应的值 3 是最大值 →res = [3]
步骤 4：i=3（元素 - 3）
- 判断队首是否过期 ：队首 1，当前窗口是
[1,2,3]（i-k=0），1 > 0，未过期 - 剔除队尾小于当前元素的索引：队尾 2（值 - 1 > -3），不弹出
- 加入当前索引 3 →
dq = [1,2,3] - 记录队首 1 对应的值 3 →
res = [3,3]
步骤 5：i=4（元素 5）
- 判断队首是否过期 ：队首 1，当前窗口是
[2,3,4]（i-k=1），1 <=1，过期弹出 →dq = [2,3] - 剔除队尾小于当前元素的索引 ：
- 队尾 3（值 - 3 <5）→ 弹出 →
dq = [2] - 队尾 2（值 - 1 <5）→ 弹出 →
dq为空
- 队尾 3（值 - 3 <5）→ 弹出 →
- 加入当前索引 4 →
dq = [4] - 记录队首 4 对应的值 5 →
res = [3,3,5]
后续步骤以此类推，最终res为[3,3,5,5,6,7]，与示例一致。
3. 完整代码实现（C++）
cpp
class Solution {
public:
vector<int> maxSlidingWindow(vector<int>& nums, int k) {
deque<int> dq; // 单调递减队列，存储元素索引
vector<int> res;
int n = nums.size();
for (int i = 0; i < n; i++) {
// 1. 移除队首：不在当前窗口内的索引（窗口范围 [i-k+1, i]）
if (!dq.empty() && dq.front() <= i - k) {
dq.pop_front();
}
// 2. 移除队尾：比当前元素小的索引（这些元素不可能成为后续窗口的最大值）
while (!dq.empty() && nums[dq.back()] < nums[i]) {
dq.pop_back();
}
// 3. 加入当前元素的索引
dq.push_back(i);
// 4. 窗口形成（i >= k-1），记录当前窗口最大值（队首）
if (i >= k - 1) {
res.push_back(nums[dq.front()]);
}
}
return res;
}
};4. 关键步骤解析
（1）为何用 "索引" 而非 "值"？
- 窗口移动时，需要判断元素是否在当前窗口内（
dq.front() <= i -k表示队首元素已不在窗口内）。若存储值，无法关联其原始位置，无法判断过期。
（2）为何 "从队尾剔除小于当前元素的索引"？
- 假设当前元素为
x，队尾元素对应的值为y，若y < x：- 未来窗口右移时，
y会比x更早被移出窗口 - 只要
x在窗口内，y就不可能成为最大值（因为x更大） - 因此，
y是 "无用信息"，可直接剔除，保证队列单调递减。
- 未来窗口右移时，
（3）为何队列是 "单调递减" 而非 "单调递增"？
- 我们需要快速获取最大值，队首作为队列的第一个元素，递减队列的队首就是最大值；若为递增队列，队尾才是最大值，获取效率会降低。
5. 复杂度分析
- 时间复杂度 ：
O(n)。每个元素最多入队 1 次、出队 1 次，总操作次数为2n，线性时间。 - 空间复杂度 ：
O(k)。队列内最多存储k个元素（窗口大小），最坏情况下所有元素递减，队列存储全部k个索引。
四、边界情况测试
1. 情况 1：k=1
- 每个元素就是自己窗口的最大值，如
nums=[5,1,2]，k=1，输出[5,1,2]。 - 代码兼容性：
i >= 0时就记录结果，队首始终是当前元素，正确。
2. 情况 2：k=n（窗口覆盖整个数组）
- 仅返回数组的最大值，如
nums=[3,1,4,2]，k=4，输出[4]。 - 代码兼容性：仅当
i = n-1时记录结果，队首是数组最大值，正确。
3. 情况 3：nums 为空或 k=0
- 直接返回空数组，代码开头隐含了此处理（
n==0 || k==0时返回空res）。
五、总结：滑动窗口问题的优化思维
解决滑动窗口类问题的核心是 **"减少重复计算"**，关键在于选择合适的数据结构维护窗口信息：
- 若需 "最大值 / 最小值"：优先考虑单调队列（递减队列找最大值，递增队列找最小值）
- 若需 "窗口内元素是否重复"：优先考虑哈希集合
- 若需 "窗口内元素和"：优先考虑前缀和数组
滑动窗口最大值的优化路径，从暴力法的O(nk)到单调队列的O(n)，本质是通过 "保留有用信息、剔除无用信息"，将重复计算转化为线性操作。还可以去做滑动窗口最小值、滑动窗口内的第 K 大元素等。