单调递减队列：

在解决题目之前，我们先来了解一下单调递减队列，它其实就是在队列的基础上多加了一些限制，如下图：

          要求队列中的元素必须按从大到小的顺序排列。

如果向单调递减队列中加入数字 1，可以直接加入，不会改变队列中递减的要求。

但是向队列中加入数字 3 就不能直接加入了。需要把队列中的 2，1 移除，然后再加入 3。  

我们可以利用java中自带的LinkedList双端队列来实现一下单调递减队列。

import java.util.LinkedList;

//单调递减队列
public class MonotonicQueue<T extends Comparable<T>> {

    private final LinkedList<T> queue = new LinkedList<>();

    public T peek(){
        return queue.peekFirst();
    }

    public void poll(){
        queue.pollFirst();
    }

    public void offer(T t){
        while(!queue.isEmpty() && queue.peekLast().compareTo(t) < 0){
            queue.pollLast();
        }
        queue.offerLast(t);
    }

    @Override
    public String toString() {
        return queue.toString();
    }

    public static void main(String[] args) {
        MonotonicQueue<Integer> q = new MonotonicQueue<>();
        for(int i : new int[]{1, 3, -1, -3, 5, 3, 6, 7}){
            q.offer(i);
            System.out.println(q);
        }
    }
}

接下来我们用单调递减队列来解决力扣的一道题目

例题：

分析：

题目说了，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。假设滑动窗口的大小 k = 3，每次窗口右移，找出滑动窗口里的最大值并把它填入一个新数组中（滑动窗口必须被填满）。

---

我们可以使用单调递减队列来找到滑动窗口中的最大值，每次向单调递减队列加入元素，队列的队头元素就是滑动窗口里面的最大值。如下图（从左往右看）。

注意：只有当滑动窗口被填满时，才获取窗口里面的最大值。

有一种情况需要注意，如下图：

当队列中的元素超过滑动窗口的范围（ k ），要及时把队头元素移除。

这里可以利用索引，当遍历到第 i 个索引时，i - k 处的元素就是过期的元素，应该移除。

也就是满足了 nums[i - k] == queue.peek() ，则移除队头元素。

注意：这里不能用队列大小当判断条件，当队列长度大于窗口大小（k）就移除元素，这样做可能会出问题。

如果把上图中的数字 -4 改为 1，当往队列加入1时，会把前面的-1，-3覆盖掉，此时队列长度小于滑动窗口值，用单调递减队列找到的最大值（数字3） 其实是过期的。

显然，此时滑动窗口的最大值为1。

代码实现：

package leetcode;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class SlidingWindowMaxnum {

    public static int[] maxSlidingWindow(int[] nums, int k) {
        //创建单调递减队列
        MonotonicQueue<Integer> queue = new MonotonicQueue<>();
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < nums.length; i++) {
            //检查队列头部元素，超过滑动窗口范围要移除
            if(i >= k && nums[i - k] == queue.peek()){
                queue.poll();
            }
            int num = nums[i];
            queue.offer(num);
            if(i >= k - 1){
                list.add(queue.peek());
            }
        }
        return list.stream().mapToInt(Integer::intValue).toArray();
    }


    public static void main(String[] args) {
        System.out.println(Arrays.toString(maxSlidingWindow(new int[]{1, 3, -1, -3, 5, 3, 6, 7}, 3))); //[3, 3, 5, 5, 6, 7]
        //System.out.println(Arrays.toString(maxSlidingWindow(new int[]{7, 2, 4}, 2))); // [7, 4]
        //System.out.println(Arrays.toString(maxSlidingWindow(new int[]{1, 3, 1, 2, 0, 5}, 3))); // [3, 3, 2, 5]
        //System.out.println(Arrays.toString(maxSlidingWindow(new int[]{-7, -8, 7, 5, 7, 1, 6, 0}, 4))); // [7, 7, 7, 7, 7]
    }
}

可以把上面的集合换成数组，做一个小小的优化，放到力扣上跑会更好。

public static int[] maxSlidingWindow(int[] nums, int k) {
        MonotonicQueue<Integer> q = new MonotonicQueue<>();
        int[] output = new int[nums.length - (k - 1)];
        for (int i = 0; i < nums.length; i++) {
            if (i >= k && nums[i - k] == q.peek()) {
                q.poll();
            }
            int num = nums[i];
            q.offer(num);
            if (i >= k - 1) {
                output[i - (k - 1)] = q.peek();
            }
        }
        return output;
    }