编号239:滑动窗口最大值

编号239:滑动窗口最大值

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

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

进阶：

你能在线性时间复杂度内解决此题吗？

提示：

1 <= nums.length <= 10^5
-10^4 <= nums[i] <= 10^4
1 <= k <= nums.length

思路

/*第一点：单调队列主要就是用来进行最值判定，如果是最大值那就是单调递减，左边队头就是要找的最大值。
        如果是取最小值则是单调递增，左边队头找最小值。
第二点：单调队列是如何进行push工作的
        如果是单调递减队列，要确保push元素比队尾元素小。
        如果大于队尾元素则将队尾元素剔除再与新的队尾进行比较，
        直到大于队尾元素或者队列为空时进行push，注意这里用的是while循环。
第三点：如何进行pop工作的，这就是要和滑动窗口结合进行理解。
        如果滑动窗口的left需要剔除的元素恰恰是队列的最左边队头元素，
        则说明队头元素应经不在此窗口内了，直接进行pop。
        如果不等于，就不用进行pop了，说明此元素还在窗口内。
第四点：返回最大值，就是返回队头元素（因为是单调递减的）。*/

动画如下：

class myQueue {

    //利用双向队列实现单向队列
    ArrayDeque<Integer> queue = new ArrayDeque<Integer>();


    public void pop(int value) {
        if (value == queue.peek()) {
            queue.pop();
        }
    }

    public void push(int value) {
        while (!queue.isEmpty() && value > queue.peekLast()) {
            queue.removeLast();
        }
        queue.addLast(value);
    }

    public int front() {
        return queue.peek();
    }


}

代码

package 栈与队列;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;

public class 滑动窗口最大值 {

    public static void main(String[] args) {
        int[] nums = {1, 3, -1, -3, 5, 3, 6, 7};
        ArrayList<Integer> list = maxSlidingWindow(nums, 3);
        System.out.println(list);

    }

    public static ArrayList<Integer> maxSlidingWindow(int[] nums, int k) {
        ArrayList<Integer> list = new ArrayList<>();
        myQueue queue = new myQueue();
        for (int i = 0; i < k; i++) {
            queue.push(nums[i]);
        }

        list.add(queue.front());

        for (int i = k; i < nums.length; i++) {
            queue.pop(nums[i - k]);
            queue.push(nums[i]);
            list.add(queue.front());
        }

        return list;
    }

}

class myQueue {

    //利用双向队列实现单向队列
    ArrayDeque<Integer> queue = new ArrayDeque<Integer>();


    public void pop(int value) {
        if (value == queue.peek()) {
            queue.pop();
        }
    }

    public void push(int value) {
        while (!queue.isEmpty() && value > queue.peekLast()) {
            queue.removeLast();
        }
        queue.addLast(value);
    }

    public int front() {
        return queue.peek();
    }


}

nums 中的每个元素最多也就被 push_back 和 pop_back 各一次，没有任何多余操作，所以整体的复杂度是 O(n)。

空间复杂度因为我们定义一个辅助队列，所以是O(k)。

---

收获

//1、在java中双向队列 利用ArrayDeque实现
 ArrayDeque<Integer> queue = new ArrayDeque<Integer>();
//2、利用双向队列实现单调队列
   // pop方法
    public void pop(int value) {
        if (value == queue.peek()) {
            queue.pop();
        }
    }
    //push方法
    public void push(int value) {
        while (!queue.isEmpty() && value > queue.peekLast()) {
            queue.removeLast();
        }
        queue.addLast(value);
    }