问题

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

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

思路一

最简单的想法就是使用最大堆优先级队列的方式。只是需要注意的地方：窗口有大小，需要每次将最老的数据移除。

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        int[] res = new int[nums.length - k + 1];
        Queue<Integer> queue = new PriorityQueue<Integer>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        for (int i = 0; i < k; i++) {
            queue.offer(nums[i]);
        }
        int index = 0;
        res[index++] = queue.peek();

        for (int i = k; i < nums.length; i++) {
            // 这个操作很耗时：需要先找到这个元素(找元素是个遍历操作)，然后移除，然后再调整
            queue.remove(nums[i - k]);
            queue.offer(nums[i]);
            res[index++] = queue.peek();
        }
        
        return res;
    }
}

上面代码应该是正确的，但是在leet-code上会超时。

• 时间复杂度：O(n*k)
• 空间复杂度：O(k)

思路二

其实，可以不用优先级队列，只是需要维护这个队列有这样的特征：队列中的某个数字肯定比他前面的数字小，也就是说，如果要入队的数字发现，他前面的数字比他都小，那么直接将这些数字移除，然后再入队。

经过上面的过程，可能会发现，队列里面的元素可能少于k个元素。

有没有可能超过k个元素呢？ 假设要入队时，队列中的最后一个元素比这个元素要大，这个元素就要入队，下次再入队时，可能会发现队列中的元素超过K个了。这样就不对了。需要入队一个元素之后，将队首的元素删除。但是有一个问题：因为入队时，已经将比自己小的元素全部移除了，这样队列中可能只有一个元素，难道也要清除？这样也不对了。因为，需要从k个元素中找到最大的。也就是，从队首中移除元素需要有约束：只有当队首的元素是数组中第[i-k+1]个元素时，才能删除。

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        Deque<Integer> deque = new LinkedList<>();
        int[] res = new int[nums.length - k + 1];
        int index = 0;
        for (int i = 0; i < nums.length; i++) {
            if (i < k - 1) {
                while (!deque.isEmpty() && deque.peekLast() < nums[i]) {
                    deque.pollLast();
                }
                deque.offerLast(nums[i]);
            } else {
                while (!deque.isEmpty() && deque.peekLast() < nums[i]) {
                    deque.pollLast();
                }
                deque.offerLast(nums[i]);
                res[index++] = deque.peekFirst();
                // 很关键
                if (!deque.isEmpty() && deque.peekFirst() == nums[i-k+1]) {
                    deque.pollFirst();
                }
            }
        }
        
        return res;
    }
}

• 时间复杂度：O(n)
• 空间复杂度：O(k)

硬广告

欢迎关注公众号：double6

参考

• 思路二的参考