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]

示例 3：

输入：nums = [1,-1], k = 1
输出：[1,-1]

示例 4：

输入：nums = [9,11], k = 2
输出：[11]

示例 5：

输入：nums = [4,-2], k = 2
输出：[4]

提示：

• 1 <= nums.length <= 105
• -104 <= nums[i] <= 104
• 1 <= k <= nums.length

题解

单调队列解法，从思路来说，最基础的

1.长度为k的区间，每挪一次，算一下区间内的最大值，这是最基础的算法

2.每挪一次，其实相比上次只有两个值有变化，挪动之后去除掉了当前区间的前一位，和新增的当前区间的最后一位

3.基于2的结论，我们需要对当前区间内的K位数字进行排序。到这里，我们可以试着用堆来处理这个问题了

4.基于前面的基础，因为这长度为k的窗口是一直单向的往后滑动的，所以，假如我们在长度为k的窗口内，下标位置为n的位置为当前窗口区间内的最大值，其实我们需要的值就剩下n位置，和n位置到窗口末尾的一个递减的有序集合。而每往后挪动一次，前面比当前位置的值小的就都可以去掉。于是，新的题解思路就出来了

import java.util.LinkedList;

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    private LinkedList<Integer> list = new LinkedList<Integer>();


    public int[] maxSlidingWindow(int[] nums, int k) {
        int[] res = new int[nums.length-k+1];

        for (int i = 0; i < nums.length; i++) {
            if (list.size()==0){
                list.add(i);
            }else {

//有个判空，不然会报空指针
                while (list.size()>0 && nums[list.getLast()] <= nums[i]){

//如果末尾的值比当前值小，那么删除
                    list.pollLast();
                }
                list.addLast(i);
                if (list.getFirst() <= i-k){//判断头部最大的值有没有超出当前区间
                    list.pollFirst();
                }
            }
            if (i+1>=k){//边界值比较容易绕，可以拿简单的i=0，k=1的情况来模拟下
                res[i-k+1] = nums[list.peekFirst()];
            }
        }

        return res;
    }
}
//leetcode submit region end(Prohibit modification and deletion)