【剑指Offer】个人学习笔记_59 - I. 滑动窗口的最大值&59 - II_队列的最大值

最新推荐文章于 2024-05-02 15:11:35 发布

JonnySu

最新推荐文章于 2024-05-02 15:11:35 发布

阅读量188

点赞数

分类专栏： Coding 文章标签：队列数据结构 java 面试 leetcode

本文链接：https://blog.csdn.net/qq_39295220/article/details/117232230

版权

Coding 专栏收录该内容

64 篇文章 0 订阅

订阅专栏

题目：

剑指 Offer 59 - I. 滑动窗口的最大值

难度困难267

给定一个数组 nums 和滑动窗口的大小 k，请找出所有滑动窗口里的最大值。

示例:

输入: 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

提示：

你可以假设 k 总是有效的，在输入数组不为空的情况下，1 ≤ k ≤ 输入数组的大小。

题目分析

有一段时间没遇到困难题了。

如果能够调用队列，然后不断出队入队，调用队的方法记录最大值在一个数组里面，那么只要一个长k的队列不断往后遍历一遍就得到结果了。

而且可以发现是有一定规律的，只要先找出来前k个的最大值，那么只要比较第k+1个与现有最大值的关系，就可以推进了。

直观感觉没有那么难，尝试进行解答。

初始解答：

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        //暂时不考虑边界条件
        int [] res = new int[nums.length - k + 1];
        res[0] = nums[0]; //先初始化
        //先找出前k个里面最大的
        for(int i = 1; i < k; i++) {
            if(res[0] < nums[i]) res[0] = nums[i];
        }
        //res[0]此时就是前k个里最大的
        for(int i = k; i < nums.length; i++) {
            if(res[i - k + 1] <= nums[i]) {
                res[i - k + 1] = nums[i];
            } 
            if(res[i - k + 1] > nums[i]) {
                res[i - k + 1] = res[i - k];
            }
        }
        return res;
    }
}

输入 [1,3,-1,-3,5,3,6,7] 3

输出 [3,3,5,3,6,7]

差别预期结果 [3,3,5,5,6,7]

想简单了，这种解法求到的应该是当前位置之前所有数的最大值，直接调库不就行了，还是不走岔路了。

要么先把窗口内的数组提取出来，然后再找最大值。

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums.length == 0) return new int [0]; //边界条件
        
        int [] res = new int[nums.length - k + 1];
        //先找出前k个里面最大的
        for(int i = 0; i < nums.length - k + 1; i++) {
            int[] tmp = Arrays.copyOfRange(nums, i, i + k);
            Arrays.sort(tmp);
            res[i] = tmp[tmp.length - 1];
        }
        return res;
    }
}

思路是对的，就是调库了，时间也有点长，主要是求最大值的办法有点笨。

执行结果：通过

显示详情添加备注

执行用时：1549 ms, 在所有 Java 提交中击败了5.01%的用户

内存消耗：44.5 MB, 在所有 Java 提交中击败了99.19%的用户

学习他人：

方法一:

mata川L5 （编辑过）2020-02-19 单调队列模板题，求滑动窗口的最值。

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums == null || nums.length == 0) {
            return new int[0];
        }
        int[] res = new int[nums.length - k + 1];
        Deque<Integer> queue = new ArrayDeque<>();
        for(int i = 0, j = 0; i < nums.length; i++) {
            if(!queue.isEmpty() && i - queue.peek() >= k) {
                queue.poll();
            }
            while(!queue.isEmpty() && nums[i] > nums[queue.peekLast()]) {
                queue.pollLast();
            }
            queue.offer(i);
            if(i >= k - 1) {
                res[j++] = nums[queue.peek()];
            }
        }

        return res;
    }
}

方法二：

Looro 1 天前

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        //单调队列
        //注意：单调队列存储的不是具体的值，而是nums的索引！
        Deque<Integer> deque = new LinkedList<>();
        int[] res = new int[nums.length];
        int j = 0;
        for(int i = 0; i < nums.length; i++){
            //判断队头是否已经滑出窗口
            if(!deque.isEmpty() && i- k + 1 > deque.getFirst()){
                deque.removeFirst();
            }
            while(!deque.isEmpty() && nums[deque.getLast()] <= nums[i]){
                deque.removeLast();
            }
            deque.addLast(i);
            if(i >= k - 1){
                res[j++] = nums[deque.getFirst()];
            }
        }
        return Arrays.copyOf(res, j);
    }
}

方法三：

邪王真眼六花花L1 2021-04-29

分享一个nlogk的，泛型效率差，如果手写一个int型大顶堆实现效率应该还不错

public int[] maxSlidingWindow(int[] nums, int k) {
        if (nums == null || nums.length == 0)
            return new int[0];
        int len = nums.length;
        int[] res = new int[len - k + 1];
        PriorityQueue<Integer> heep = new PriorityQueue<>(Comparator.comparingInt(a -> a));
        for (int i = 0; i < k; i++) {
            heep.add(nums[i]);
        }
        res[0] = heep.peek();
        for (int i = k; i < len; i++) {
            heep.remove(nums[i - k]);
            heep.add(nums[i]);
            res[i - k + 1] = heep.peek();
        }
        return res;
    }

方法四：

K神，队列

作者：jyd
链接：https://leetcode-cn.com/problems/hua-dong-chuang-kou-de-zui-da-zhi-lcof/solution/mian-shi-ti-59-i-hua-dong-chuang-kou-de-zui-da-1-6/
来源：力扣（LeetCode）

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums.length == 0 || k == 0) return new int[0];
        Deque<Integer> deque = new LinkedList<>();
        int[] res = new int[nums.length - k + 1];
        for(int j = 0, i = 1 - k; j < nums.length; i++, j++) {
            // 删除 deque 中对应的 nums[i-1]
            if(i > 0 && deque.peekFirst() == nums[i - 1])
                deque.removeFirst();
            // 保持 deque 递减
            while(!deque.isEmpty() && deque.peekLast() < nums[j])
                deque.removeLast();
            deque.addLast(nums[j]);
            // 记录窗口最大值
            if(i >= 0)
                res[i] = deque.peekFirst();
        }
        return res;
    }
}

可以将 “未形成窗口” 和 “形成窗口后” 两个阶段拆分到两个循环里实现。代码虽变长，但减少了冗余的判断操作。

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums.length == 0 || k == 0) return new int[0];
        Deque<Integer> deque = new LinkedList<>();
        int[] res = new int[nums.length - k + 1];
        // 未形成窗口
        for(int i = 0; i < k; i++) {
            while(!deque.isEmpty() && deque.peekLast() < nums[i])
                deque.removeLast();
            deque.addLast(nums[i]);
        }
        res[0] = deque.peekFirst();
        // 形成窗口后
        for(int i = k; i < nums.length; i++) {
            if(deque.peekFirst() == nums[i - k])
                deque.removeFirst();
            while(!deque.isEmpty() && deque.peekLast() < nums[i])
                deque.removeLast();
            deque.addLast(nums[i]);
            res[i - k + 1] = deque.peekFirst();
        }
        return res;
    }
}

angeninL3 （编辑过）2020-10-03 放个java的注解版，方便理解。

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        //单调队列
        //下面是要注意的点：
        //队列按从大到小放入
        //如果首位值（即最大值）不在窗口区间，删除首位
        //如果新增的值小于队列尾部值，加到队列尾部
        //如果新增值大于队列尾部值，删除队列中比新增值小的值，如果在把新增值加入到队列中
        //如果新增值大于队列中所有值，删除所有，然后把新增值放到队列首位，保证队列一直是从大到小
        if (nums.length == 0)   return nums;

        Deque<Integer> deque = new LinkedList<>();
        int[] arr = new int[nums.length - k + 1];
        int index = 0;  //arr数组的下标
        //未形成窗口区间
        for (int i = 0; i < k; i++) {
            //队列不为空时，当前值与队列尾部值比较，如果大于，删除队列尾部值
            //一直循环删除到队列中的值都大于当前值，或者删到队列为空
            while (!deque.isEmpty() && nums[i] > deque.peekLast())  deque.removeLast();
            //执行完上面的循环后，队列中要么为空，要么值都比当前值大，然后就把当前值添加到队列中
            deque.addLast(nums[i]);
        }
        //窗口区间刚形成后，把队列首位值添加到队列中
        //因为窗口形成后，就需要把队列首位添加到数组中，而下面的循环是直接跳过这一步的，所以需要我们直接添加
        arr[index++] = deque.peekFirst();
        //窗口区间形成
        for (int i = k; i < nums.length; i++) {
            //i-k是已经在区间外了，如果首位等于nums[i-k]，那么说明此时首位值已经不再区间内了，需要删除
            if (deque.peekFirst() == nums[i - k])   deque.removeFirst();
            //删除队列中比当前值大的值
            while (!deque.isEmpty() && nums[i] > deque.peekLast())  deque.removeLast();
            //把当前值添加到队列中
            deque.addLast(nums[i]);
            //把队列的首位值添加到arr数组中
            arr[index++] = deque.peekFirst();
        }
        return arr;
    }
}

题目：

剑指 Offer 59 - II. 队列的最大值

难度中等246

请定义一个队列并实现函数 max_value 得到队列里的最大值，要求函数max_value、push_back 和 pop_front 的均摊时间复杂度都是O(1)。

若队列为空，pop_front 和 max_value 需要返回 -1

示例 1：

输入: 
["MaxQueue","push_back","push_back","max_value","pop_front","max_value"]
[[],[1],[2],[],[],[]]
输出: [null,null,null,2,1,2]

示例 2：

输入: 
["MaxQueue","pop_front","max_value"]
[[],[],[]]
输出: [null,-1,-1]

限制：

1 <= push_back,pop_front,max_value的总操作数 <= 10000
1 <= value <= 10^5

题目分析

这种定义类的题目简直了，直接懵逼。

入队出队，然后寻找队内最大元素，肯定和上一题有关系。

还是参考别人多学习吧。

立夏DL1 （编辑过）2020-03-07

可能有人看不懂题，本小白说一下我自己的理解：输入的两个列表，其元素分别是执行的函数与给的值。以输入1为例：

1、  “MaxQueue”  生成队列
        []                    传入的值为空
        无输出，故输出为null
2、  "push_back"  向队列传入元素
        [1]                  传入的值为1
        此时队列中只有一个1
        函数无输出，故输出为null
3、  "push_back"  向队列传入元素
        [2]                  传入的值为2
        此时队列为    --进-> [2,1] --出->
        函数无输出，故输出为null
4、   "max_value" 求队列中的最大值
        []                    传入的值为空
        输出为2
5、   "pop_front"   删除队列头部元素
        []                    传入的值为空
        函数pop_front还要输出删除元素的值，故输出为1
6、   "max_value" 求队列中的最大值
        []                    传入的值为空
         此时队列为[2]，所以最大值输出为2。

希望能起到一点作用，也感谢大佬们能指教我描述不准确的的地方。（不知为何，觉得自己写的很别扭）（编辑：我打字的时候是分行的，但预览又成一整段了，没办法只能用代码块了，看着更别扭了- -，但总比一整段清晰一点）

初始解答：

学习了K神用链表辅助的思路

class MaxQueue {
    Queue<Integer> queue; //一个放数据，一个辅助
    Deque<Integer> deque;
    public MaxQueue() {
        queue = new LinkedList<>(); //用链表维护递减序列
        deque = new LinkedList<>();
    }
    public int max_value() {
        return deque.isEmpty() ? -1 : deque.peekFirst(); //检索此deque队列的第一个元素(但不删除)，则返回null如果此deque队列为空。
    }
    public void push_back(int value) {
        queue.offer(value);
        while(!deque.isEmpty() && deque.peekLast() < value)
            deque.pollLast();
        deque.offerLast(value);
    }
    public int pop_front() {
        if(queue.isEmpty()) return -1;
        if(queue.peek().equals(deque.peekFirst()))
            deque.pollFirst();
        return queue.poll();
    }
}

执行结果：通过

显示详情添加备注

执行用时：41 ms, 在所有 Java 提交中击败了61.43%的用户

内存消耗：46.3 MB, 在所有 Java 提交中击败了50.05%的用户

学习他人：

方法一:

mata川L5 （编辑过）2020-02-20

其实本质上是一个求滑动窗口最大值的问题。这个队列可以看成是一个滑动窗口，入队就是将窗口的右边界右移，出队就是将窗口的左边界右移。

既然是求解滑动窗口的最大值问题，那就变成了模板题，直接套单调队列模板即可。

class MaxQueue {
    private Deque<Integer> queue;
    private Deque<Integer> help;

    public MaxQueue() {
        queue = new ArrayDeque<>();
        help = new ArrayDeque<>();
    }
    
    public int max_value() {
        return queue.isEmpty() ? -1 : help.peek();
    }
    
    public void push_back(int value) {
        queue.offer(value);
        while(!help.isEmpty() && value > help.peekLast()) {
            help.pollLast();
        }
        help.offer(value);
    }
    
    public int pop_front() {
        if(queue.isEmpty()) {
            return -1;
        }
        int val = queue.pop();
        if(help.peek() == val) {
            help.pop();
        }
        return val;
    }
}

方法二：

林距离

2 天前

单调队列思路

class MaxQueue {

    private Deque<Integer> dataQueue;
    private Deque<Integer> maxQueue;

    public MaxQueue() {
        dataQueue = new ArrayDeque<>();
        maxQueue = new ArrayDeque<>();
    }
    
    public int max_value() {
        if (maxQueue.isEmpty())
            return -1;

        return maxQueue.peek();
    }
    
    public void push_back(int value) {
        dataQueue.add(value);
        while (!maxQueue.isEmpty() && value > maxQueue.peekLast())
            maxQueue.pollLast();
        maxQueue.add(value);
    }
    
    public int pop_front() {
        if (dataQueue.isEmpty())
            return -1;
        int value = dataQueue.poll();
        if (maxQueue.peek() == value)
            maxQueue.poll();

        return value;
    }
}

方法三：

K神题目理解

解题思路：

对于普通队列，入队 push_back() 和出队 pop_front() 的时间复杂度均为 O(1) ；本题难点为实现查找最大值 max_value() 的 O(1)O(1) 时间复杂度。

假设队列中存储 NN 个元素，从中获取最大值需要遍历队列，时间复杂度为 O(N) ，单从算法上无优化空间。

如下图所示，最直观的想法是维护一个最大值变量，在元素入队时更新此变量即可；但当最大值出队后，并无法确定下一个次最大值，因此不可行。

作者：jyd
链接：https://leetcode-cn.com/problems/dui-lie-de-zui-da-zhi-lcof/solution/jian-zhi-offer-59-ii-dui-lie-de-zui-da-z-0pap/
来源：力扣（LeetCode）

考虑利用数据结构来实现，即经常使用的 “空间换时间” 。如下图所示，考虑构建一个递减列表来保存队列所有递减的元素，递减链表随着入队和出队操作实时更新，这样队列最大元素就始终对应递减列表的首元素，实现了获取最大值 O(1)时间复杂度。

class MaxQueue {
    Queue<Integer> queue;
    Deque<Integer> deque;
    public MaxQueue() {
        queue = new LinkedList<>();
        deque = new LinkedList<>();
    }
    public int max_value() {
        return deque.isEmpty() ? -1 : deque.peekFirst();
    }
    public void push_back(int value) {
        queue.offer(value);
        while(!deque.isEmpty() && deque.peekLast() < value)
            deque.pollLast();
        deque.offerLast(value);
    }
    public int pop_front() {
        if(queue.isEmpty()) return -1;
        if(queue.peek().equals(deque.peekFirst()))
            deque.pollFirst();
        return queue.poll();
    }
}

Java队列常用方法

1、add()和offer()区别:

add()和offer()都是向队列中添加一个元素。一些队列有大小限制，因此如果想在一个满的队列中加入一个新项，调用 add() 方法就会抛出一个 unchecked 异常，而调用 offer() 方法会返回 false。因此就可以在程序中进行有效的判断！

2、poll()和remove()区别：

remove() 和 poll() 方法都是从队列中删除第一个元素。如果队列元素为空，调用remove() 的行为与 Collection 接口的版本相似会抛出异常，但是新的 poll() 方法在用空集合调用时只是返回 null。因此新的方法更适合容易出现异常条件的情况。

3、element() 和 peek() 区别：

element() 和 peek() 用于在队列的头部查询元素。与 remove() 方法类似，在队列为空时， element() 抛出一个异常，而 peek() 返回 null。

下面是Java中Queue的一些常用方法：

add 增加一个元索如果队列已满，则抛出一个IIIegaISlabEepeplian异常

remove 移除并返回队列头部的元素如果队列为空，则抛出一个

NoSuchElementException异常

element 返回队列头部的元素如果队列为空，则抛出一个NoSuchElementException异常

offer 添加一个元素并返回true 如果队列已满，则返回false

poll 移除并返问队列头部的元素如果队列为空，则返回null

peek 返回队列头部的元素如果队列为空，则返回null

put 添加一个元素如果队列满，则阻塞

take 移除并返回队列头部的元素如果队列为空，则阻塞