LeetCode题练习与总结：滑动窗口最大值--239

一、题目描述

给你一个整数数组 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 <= nums.length <= 10^5
• -10^4 <= nums[i] <= 10^4
• 1 <= k <= nums.length

二、解题思路

• 使用一个双端队列（deque）来保存当前滑动窗口中的最大值。队列中的元素是数组元素的索引，而不是元素的值。
• 遍历数组，对于每个元素：
  • 将队列尾部所有小于当前元素的索引出队，因为这些元素不可能是滑动窗口的最大值。
  • 将当前元素的索引加入队列尾部。
  • 如果队列头部的索引已经不在滑动窗口的范围内（即索引小于 i - k + 1），则将其出队。
  • 当遍历的索引大于等于 k - 1 时，将队列头部的元素（即滑动窗口的最大值）加入结果数组。
• 返回结果数组。

三、具体代码

import java.util.Deque;
import java.util.LinkedList;

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if (nums == null || nums.length < 2) return nums;
        // 结果数组的长度是 nums.length - k + 1
        int[] res = new int[nums.length - k + 1];
        // 双端队列，保存的是数组元素的索引
        Deque<Integer> deque = new LinkedList<>();
        for (int i = 0; i < nums.length; i++) {
            // 将队列尾部所有小于当前元素的索引出队
            while (!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
                deque.pollLast();
            }
            // 将当前元素的索引加入队列尾部
            deque.offerLast(i);
            // 如果队列头部的索引已经不在滑动窗口的范围内，则将其出队
            if (deque.peekFirst() < i - k + 1) {
                deque.pollFirst();
            }
            // 当遍历的索引大于等于 k - 1 时，将队列头部的元素加入结果数组
            if (i >= k - 1) {
                res[i - k + 1] = nums[deque.peekFirst()];
            }
        }
        return res;
    }
}

四、时间复杂度和空间复杂度

1. 时间复杂度

• 遍历数组 nums 一次，每次遍历会进行以下操作：
  • 出队操作：在双端队列 deque 中，对于每个元素最多只会出队一次，因为一旦一个元素被出队，它就不会再次进入队列。这意味着对于整个数组，每个元素最多只会出队一次，所以出队操作的总时间复杂度是 O(n)。
  • 入队操作：每个元素会被加入队列一次，因此入队操作的总时间复杂度也是 O(n)。
  • 检查并可能出队队首元素：由于队首元素只有在滑动窗口移动到它不在窗口内的位置时才会被出队，所以每个元素最多只会被检查一次，并且最多出队一次，因此这一部分的总时间复杂度也是 O(n)。

综合以上操作，算法的总时间复杂度是 O(n)，因为所有操作都是线性的，并且没有嵌套循环。

2. 空间复杂度

• 双端队列 deque：在任何时候，队列中最多只会有 k 个元素，因为当队列中的元素数量超过 k 时，队首元素（如果它不在当前窗口内）会被移除。因此，队列的空间复杂度是 O(k)。
• 结果数组 res：结果数组的长度是 nums.length - k + 1，因此它占用的空间是 O(n)，其中 n 是输入数组 nums 的长度。

综上所述，算法的空间复杂度是 O(n + k)，但由于 k 是滑动窗口的大小，它通常小于或等于 n，因此可以简化为 O(n)。这意味着算法的空间复杂度主要由结果数组决定。

五、总结知识点

• 类定义：

  • class 关键字用于定义一个类。
  • 类名通常以大写字母开头。

• 方法定义：

  • public 关键字指定方法的访问权限，允许其他类访问这个方法。
  • int[] 表示这个方法返回一个整数数组。
  • 方法名通常以小写字母开头，遵循驼峰命名法。

• 数组操作：

  • 数组的声明和初始化：int[] res = new int[nums.length - k + 1];
  • 访问数组元素：res[i - k + 1] = nums[deque.peekFirst()];

• 条件语句：

  • if 语句用于条件判断。
  • else 语句用于处理 if 条件不满足的情况。

• 循环语句：

  • for 循环用于遍历数组。

• 数据结构：

  • Deque 接口用于表示双端队列。
  • LinkedList 类实现了 Deque 接口，提供了双端队列的实现。

• 队列操作：

  • offerLast() 方法用于在队列尾部添加元素。
  • pollFirst() 方法用于移除队列头部的元素。
  • pollLast() 方法用于移除队列尾部的元素。
  • peekFirst() 方法用于获取队列头部的元素，但不移除它。
  • peekLast() 方法用于获取队列尾部的元素，但不移除它。

• 逻辑操作：

  • while 循环用于在满足条件时重复执行代码块。
  • isEmpty() 方法用于检查队列是否为空。

• 边界条件处理：

  • 检查输入数组是否为 null 或长度小于 2，如果是，则直接返回输入数组。

• 算法思想：

  • 使用双端队列来维护滑动窗口中的最大值，通过保持队列的单调递减顺序，使得队列头部始终是窗口中的最大值。

以上就是解决这个问题的详细步骤，希望能够为各位提供启发和帮助。