先来看看题目

给定一个数组 nums 和滑动窗口的大小 k，请找出所有滑动窗口里的最大值。 示例:

输入: 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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/hua-dong-chuang-kou-de-zui-da-zhi-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

一般的暴力解法，就是维护一个滑动窗口，在不停的滑动中，循环遍历每一个值来获取最大值，但这一解法显然时间复杂度过高，需要$O(nk)$的复杂度，那我们可以稍稍思考一下，在哪些地方可以进行优化。

以我来说，我首先想到的是维护一个最大值的属性，每次移动，都将移入的元素与当前最大值进行比较，并取较大的一个，将移出的元素与当前最大值进行比较，若相等则将最大值变成上一个最大值。

想到这里，我们也发现了只维护一个最大值的属性是不足够的，因为我们没法获取到移出当前最大值后的上一最大值，其实我们已经离答案很近了，我们可以用一个单调队列来维护一个最大值队列。

当我们移入一个元素时，我们将队尾比该元素小的元素全部pop掉，然后把该元素的索引加到队尾，当要求当前滑动窗口的最大值时，先要将不是该滑动窗口区间的队头元素全部pop掉（这也是我们存索引的原因），然后返回队头值。

代码如下：

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if (k == 0) return new int[0];
        Deque<Integer> queue = new LinkedList<>();
        int[] ans = new int[nums.length - k + 1];
        int index = 0;
        for (int i = 0; i < nums.length; i++){  
            while (!queue.isEmpty() && nums[queue.peekLast()] <= nums[i]) queue.pollLast();
            queue.addLast(i);
            while (!queue.isEmpty() && queue.peekFirst() <= i - k) queue.pollFirst();
            if (i >= k - 1) ans[index++] = nums[queue.peekFirst()];
        }
        return ans;
    }

一些解题过程中的疑惑

为什么我能保证pop掉的队尾元素以后不会作为最大值出现？

我们假设遇到的当前元素下标为$i$，队尾元素下标为$j$，由题可得，$i > j$，所以当包含有$nums[i]$的时候， 当我们需要将$nums[j]$从滑动窗口中移出的时候窗口中必然是包含$nums[i]$的（除非窗口大小为1，该情况不存在$i$会把单调队列中的$j$踢掉的情景），所以当前的窗口最大值必然是大于等于$nums[i]$的，所以我们不会用到$nums[j]$的值。

一道类似的题目

请定义一个队列并实现函数 max_value 得到队列里的最大值，要求函数max_value、push_back 和 pop_front 的均摊时间复杂度都是O(1)。

若队列为空，pop_front 和 max_value 需要返回 -1

示例 1：

输入: 
["MaxQueue","push_back","push_back","max_value","pop_front","max_value"]
[[],[1],[2],[],[],[]]
输出: [null,null,null,2,1,2]
示例 2：

输入: 
["MaxQueue","pop_front","max_value"]
[[],[],[]]
输出: [null,-1,-1]
 

限制：

1 <= push_back,pop_front,max_value的总操作数 <= 10000
1 <= value <= 10^5

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/dui-lie-de-zui-da-zhi-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

该题也可以看作一个滑动窗口题，只不过滑动窗口的大小不是固定的，我们也可以用单调队列的思路来解决：

每当加入一个元素时，将比该元素小的单调队列队尾值全部pop掉，并加入队列尾部；每当pop掉一个元素时，若该元素与单调队列队首元素比较，若相等，则pop掉单调队列队首。 代码如下：

class MaxQueue {
    private Deque<Integer> queue = new LinkedList<>();
    private Deque<Integer> helpQueue = new LinkedList<>();
    public MaxQueue() {

    }
    
    public int max_value() {
        return queue.isEmpty() ? -1 : helpQueue.peek();
    }
    
    public void push_back(int value) {
        queue.offer(value);
        while (!helpQueue.isEmpty() && value > helpQueue.peekLast()) helpQueue.pollLast();
        helpQueue.offer(value);
    }
    
    public int pop_front() {
        if (queue.isEmpty()) return -1;
        if (queue.peek().equals(helpQueue.peek())) helpQueue.pop();
        return queue.pop(); 
    }
}

上述两题是一模一样的思路，所以我们甚至可以用第二题的这一数据结构解决第一题：

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if (k == 0) return new int[0];
        MaxQueue queue = new MaxQueue();
        int[] ans = new int[nums.length - k + 1];
        int index = 0;
        for (int i = 0; i < nums.length; i++){
            queue.push_back(nums[i]);
            if (i >= k - 1) {ans[index++] = queue.max_value();queue.pop_front();}
        }
        return ans;
    }
}

class MaxQueue {
    private Deque<Integer> queue = new LinkedList<>();
    private Deque<Integer> helpQueue = new LinkedList<>();
    public MaxQueue() {

    }
    
    public int max_value() {
        return queue.isEmpty() ? -1 : helpQueue.peek();
    }
    
    public void push_back(int value) {
        queue.offer(value);
        while (!helpQueue.isEmpty() && value > helpQueue.peekLast()) helpQueue.pollLast();
        helpQueue.offer(value);
    }
    
    public int pop_front() {
        if (queue.isEmpty()) return -1;
        if (queue.peek().equals(helpQueue.peek())) helpQueue.pop();
        return queue.pop(); 
    }
}

解题时遇到的bug

在解第二题的时候我本来是这样写的：

if (queue.peek() == helpQueue.peek()) helpQueue.pop();

这是绝对不行的！这是比较的两个Integer的对象地址值，有些时候是判断正确的，因为若Integer的数值在[-128, 127]之内，java会给这些数创建常量池，在该范围内的对象地址都是相等的，所以这个判断会正确，但超过这个范围，都会new一个新对象，所以判断都是不正确的，对象值相等的判断应使用.equals()!!!!