239. 滑动窗口最大值

239. 滑动窗口最大值

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

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

示例 1：

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

示例 2：

输入：nums = [1], k = 1
输出：[1]

思考

首先考虑两种情况

• 情况一: 滑动窗口大小大于数组长度，即k>nums.length
  • 转化为获取该数组的最大值
• 情况二：滑动窗口大小小于数组长度，即k≤nums.length
  • 这里可以用一个队列保存滑动窗口，每次出一个进一个。
  • 这里我们需要获取队列里面的最大值

我们需要的队列应该有什么性质？

了解双端队列Java中的使用

它应该是一个单调双端队列，出口放着的应该是最大值，后面的都是递减的数。

                                       出口    大 <- - -  小  入口

随着滑动窗口的移动，我们每次都可以再出口处获得该窗口的最大值，即队列的head

原始的队列不满足我们的需求，所以我们需要自定义队列。

设计单调队列的时候，pop，和push操作要保持如下规则：

1. pop(value)：如果窗口移除的元素value等于单调队列的出口元素，那么队列弹出元素，否则不用任何操作
2. push(value)：如果push的元素value大于入口元素的数值，那么就将队列入口的元素弹出，直到push元素的数值小于等于队列入口元素的数值为止

首先我们需要对队列进行初试化，输入第一个窗口内的数值，之后移动指向窗口头端和尾端的指针，对队列进行操作即可。

package 力扣;

import java.lang.reflect.Array;
import java.util.*;

/**
 * @author yyq
 * @create 2022-03-31 8:52
 */
public class leetcode239 {
    public static void main(String[] args) {
        int[] ints = maxSlidingWindow(new int[]{1, 3, -1, -3, 5, 3, 6, 7}, 3);
        for (int anInt : ints) {
            System.out.println(anInt);
        }
        System.out.println(maxSlidingWindow(new int[]{1, 3, -1, -3, 5, 3, 6, 7}, 3));
    }
    public static int[] maxSlidingWindow(int[] nums, int k) {
        int[] maxs = new int[nums.length-k+1];
        YYQQueue deque = new YYQQueue();
        if(nums.length<=k){
            Arrays.sort(nums);
            return new int[]{nums[nums.length-1]};
        }
        if(nums.length>k){
            // 初始化队列
            for (int i = 0; i < k; i++) {
                deque.push(nums[i]);
            }

            int prepoint = k-1; //指向当前窗口最后一个
            int backpoint = 0;  //指向当前窗口第一个
            while(prepoint<nums.length){
                maxs[backpoint] = deque.getMax();
                deque.pop(nums[backpoint]);
                if(prepoint+1 == nums.length) break;
                deque.push(nums[prepoint+1]);
                prepoint++;
                backpoint++;
            }

        }
        return maxs;
    }


}

class YYQQueue{
    Deque<Integer> deque;


    public YYQQueue() {
        deque=new LinkedList<>();
    }

    // push到尾端
    //      如果小于尾端数据直接进
    //      如果大于尾端数据，pop出尾端数据，直到它小于尾端数据或者它作为头端数据
    public void push(int num){
        if (deque.isEmpty()){
            deque.add(num);
            return;
        }
        if(num<=deque.getLast()){
            deque.addLast(num);
        }else {
            while(num>deque.getLast()){

                deque.pollLast();
                if (deque.isEmpty()) {
                    deque.add(num);
                    return;
                }
            }
            deque.add(num);
        }

    }
    // pop一个数 如果它等于开端数据 pop开端数据，如果不是开端数据不用管
    public void pop(int num){
        if (deque.getFirst()==num) {
            deque.pollFirst();
        }
    }

    public int getMax(){
        return deque.peek();
    }
}