剑指offer(59)——滑动窗口的最大值

一、题目描述

给定一个数组 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

二、解题思路

输出数组大小计算，假设数组长度为n，窗口大小为k，则数组长度为 n - k + 1，其中n-k为窗口可以移动的距离，然后需要加上窗口本身。如图所示，数组长度为8，窗口大小为3，则输出的数组大小为6。

1、思路一：暴力法

按照题目要求找到窗口的边界，在窗口中找到最大值然后移动窗口。

1.1 代码实现

public int[] maxSlidingWindow(int[] nums, int k) {
    if(nums.length < k || k == 0 || nums.length == 0)
        return new int[0];
    int[] res = new int[nums.length-k+1];
    int index = 0;
    for(int i = k-1;i<nums.length;i++){
        int temp = - Integer.MAX_VALUE,j=0,n=i;
        while(j<k){
            temp = Math.max(temp,nums[n--]);
            j++;
        }
        res[index++] = temp;
    }
    return res;
}

1.2 复杂度分析

这种算法时间复杂度很高，需要比较 (n-k+1)*k 次

• 时间复杂度：O(n*k)，k为滑动窗口的大小
• 空间复杂度：O(1)，输出说需要的数组不算，需要常数级的空间

2、思路二：双端队列

思路一中每个滑动窗口找最大值都要全部比较一次，上一次找到的最大值怼于下一次找最大值没有帮助，这是我们对思路的算法进行优化的切入点。

2.1 算法思路

采用双端队列，维护一个单调队列，使得滑动窗口每前进一步，原队列的队列头为上个窗口的最大值，前进一步后，窗口中的每一个值都与队列中的队尾元素进行比较，删除队列中所有比当前元素小的值，然后插入该元素，继续遍历下一个元素，最后队列的头一定是队列中最大的元素。

2.2 代码实现

public int[] maxSlidingWindow(int[] nums, int k) {
    int len = nums.length;
    if(len == 0 || k==0 || len < k){
        return nums;
    }
    Deque<Integer> deque = new LinkedList<>();
    //数组长度减去窗口大小为窗口移动的距离
    int[] res = new int[len - k + 1];
    //数组的下标
    int index = 0;
    //未形成窗口区间
    for(int i = 0;i < k;i++){
        //队列不为空，当前值与队列尾部比较，如果大于，删除队列尾部值
        //一直循环删除到队列中的值都大于当前值，或者删除到队列为空
        //即删除队列中小于当前值的数
        while(!deque.isEmpty() && nums[i] > deque.getLast()){
            deque.removeLast();
        }
        //执行完上面的循环后，队列中要么为空，要么都比当前值大，然后就把当前值添加到队列尾部
        deque.addLast(nums[i]);
    }
    //窗口区间刚形成后，把队列首位值添加到队列中
    //因为窗口形成后，就需要把队列首位添加到数组中，下面的循环跳过了这一步
    res[index++] = deque.getFirst();
    //窗口区间形成
    for(int i = k;i < len;i++){
        //i-k已经是区间外了，如果首位等于nums[i-k](首位为最大的数),
        //那么说明此时首位已经不在区间内了，需要删除
        if(deque.getFirst() == nums[i - k]){
            deque.removeFirst();
        }
        //删除队列中比当前值小的数
        while(!deque.isEmpty() && nums[i] > deque.getLast()){
            deque.removeLast();
        }
        deque.addLast(nums[i]);
        res[index++] = deque.getFirst();
    }
    return res;
}

2.3 复杂度分析

• 时间复杂度：O(n)，遍历数组nums一次需要O(n)；每个元素最多仅入队出队一次，单调队列占用O(2n)。
• 空间复杂度：O(k)，双端队列中最多同时存在k个元素(k为窗口大小)。