代码随想录算法训练营之JAVA｜第十一天| 239. 滑动窗口最大值

今天是第11天刷leetcode，立个flag。

算法挑战链接

239. 滑动窗口最大值https://leetcode.cn/problems/sliding-window-maximum/description/

第一想法

题目理解：找到滑动窗口中最大的值，写入数组中，返回该数组即可。

第一个想法是暴力循环，我只需要对窗口的值进行排序，然后取出最大值就行。简单。

代码如下：

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        // 暴力解法
        if (nums == null || nums.length < 1 || k < 1) {
            throw new IllegalArgumentException();
        }
        int length = nums.length;
        int[] res = new int[length - k + 1];
        // i 为窗口的左边界
        for (int i = 0; i < length - k + 1; i++) {
            int max = Integer.MIN_VALUE;
            // j 从左边界开始，滑过窗口的范围
            for (int j = i; j < i + k; j++) {
                max = Math.max(max, nums[j]); // 记录窗口内的最大值
            }
            res[i] = max;
        }
        return res;
    }
}

 结果是超时了～～～～

看完代码随想录之后的想法 

代码随想录的做法是使用单调队列来完成的。这个做法是极好的。

单调队列就是记录窗口内值的单调性。你可以想象有一个数据结构，他可以：

• 弹出第一个元素
• 往队尾添加一个元素
• 返回该队列的最大值

如果有这个一个数据结构，那么这道题不是轻松拿捏吗？

但是很可惜我们并没有这样一种数据结构，因此需要我们自己去实现这样一种数据接口。要实现这个数据结构也是比较简单的。

只需要保证队列是递减的即可。

对应三个操作应该是这样的：

• 弹出第一个元素：
  • 如果该元素是队列的第一位，则在队列中移除第一位
  • 如果该元素不是队列的第一位，则不操作
• 往队尾添加一个元素
  • 如果该元素大于最后一位的值，则移除最后一位，一直循环对比，找到比该元素大的值，并且放在该元素的后面
  • 如果该元素小于最后一位的值，则在末尾添加。
• 返回该队列的最大值，返回队列的头

单调队列的实现如下：

class MyDeQueue {
    Deque<Integer> deque = new LinkedList<>();
    //弹出元素时，比较当前要弹出的数值是否等于队列出口的数值，如果相等则弹出
    //同时判断队列当前是否为空
    public void poll(int val) {
        if (!deque.isEmpty() && val == deque.peek()) {
            deque.poll();
        }
    }
    //添加元素时，如果要添加的元素大于入口处的元素，就将入口元素弹出
    //保证队列元素单调递减
    //比如此时队列元素3,1，2将要入队，比1大，所以1弹出，此时队列：3,2
    public void add(int val) {
        while (!deque.isEmpty() && val > deque.getLast()) {
            deque.removeLast();
        }
        deque.add(val);
    }
    //队列队顶元素始终为最大值
    public int peek() {
        return deque.peek();
    }
}

 那么题目的解答也就比较简单了

class Solution {
    
    class MyDeQueue {
    Deque<Integer> deque = new LinkedList<>();
    //弹出元素时，比较当前要弹出的数值是否等于队列出口的数值，如果相等则弹出
    //同时判断队列当前是否为空
    public void poll(int val) {
        if (!deque.isEmpty() && val == deque.peek()) {
            deque.poll();
        }
    }
    //添加元素时，如果要添加的元素大于入口处的元素，就将入口元素弹出
    //保证队列元素单调递减
    //比如此时队列元素3,1，2将要入队，比1大，所以1弹出，此时队列：3,2
    public void add(int val) {
        while (!deque.isEmpty() && val > deque.getLast()) {
            deque.removeLast();
        }
        deque.add(val);
    }
    //队列队顶元素始终为最大值
    public int peek() {
        return deque.peek();
    }
}
    
    
    public int[] maxSlidingWindow(int[] nums, int k) {
//有效值校验
        if (nums.length==1) {
            return nums;
        }
        if (nums.length < k) {
            k = nums.length;
        }
        //初始化
        MyDeQueue deQueue = new MyDeQueue();
        int[] result = new int[nums.length - k + 1];
        for (int i = 0; i < k; i++) {
            deQueue.add(nums[i]);
        }
        result[0] = deQueue.peek();
        int index = 0;
        //滑动窗口
        for (int i = k; i < nums.length; i++) {
            deQueue.poll(nums[index]);
            deQueue.add(nums[i]);
            index++;
            result[index]=deQueue.peek();
        }
        return result;
    }
}

实现过程中遇到哪些困难 

实现单调队列的时候是比较不能理解的，但是慢慢梳理后发现还是可以理解的。

梳理的过程使用的是工程的思维，单调队列有三个操作，那就从一个操作入手。搞定一个操作再去研究第二个操作，依次递推。也就是将大问题转化成小问题，再去解决小问题

今日收获

了解了另一种数据结构——单调队列