滑动窗口最大值(来源力扣)

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回 滑动窗口中的最大值 。

用优先队列（大顶堆）来存储每一个窗口中的值，堆顶即为最大的元素，需要注意的有两点：优先队列的cell需要设计成数组，来存放每一个元素和其下标的对应，存元素是为了对窗口中的值进行排序；存下标是为了判断所取的堆顶元素是不是该窗口中的值，因为其有可能是窗口之前的值。

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        PriorityQueue<int[]> pq = new PriorityQueue<>(new Comparator<int[]>() {
            public int compare(int[] a, int[] b) {
                return a[0] != b[0] ? b[0] - a[0] : b[1] - a[1];
            }
        });
        int n = nums.length;
        int[] ans = new int[n - k + 1];
        for(int i = 0; i < k; i++) {
            pq.offer(new int[] {nums[i], i});
        }
        ans[0] = pq.peek()[0];
        for(int i = k; i < n; i++) {
            pq.offer(new int[] {nums[i], i});
            while(pq.peek()[1] <= i - k) {
                pq.poll();
            }
            ans[i - k + 1] = pq.peek()[0];
        }
        return ans;
    }
}

单调栈
使用单调栈也可以实现，和有点队列类似，单调栈中需要存严格递减的序列，这样栈顶元素即为要找的最大值，栈中存储是下标，在取栈顶元素的时候需要注意栈顶元素是不是在该窗口内，不在的话需要去除掉。

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