LeetCode239——滑动窗口最大值

题目描述

给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}； 针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个： {[2,3,4],2,6,2,5,1}， {2,[3,4,2],6,2,5,1}， {2,3,[4,2,6],2,5,1}， {2,3,4,[2,6,2],5,1}， {2,3,4,2,[6,2,5],1}， {2,3,4,2,6,[2,5,1]}。

思路1：暴力求解

首先计算需要遍历多少次（每次取出三个），计算次数=length - size + 1；所以，然后每次依次取出三个放人到一个临时的ArrayList中，然后使用Collections对临时的ArrayList进行排序，将临时ArrayList中的最大值放入到这个list中，这样一来，遍历就得到每次的最大值，然后都放入到这个list中，最后返回这个list就可以了。

实现：

import java.util.ArrayList;
import java.util.Collections;
public class Solution {
    public ArrayList<Integer> maxInWindows(int [] num, int size)
    {
         /*
             这一道题的主要做法是每次取三个，然后放在一个ArrayList中，然后使用Collections
             的球最大值，这里并没有改变原数组。然后把最大值放入到列表中。
         */
        if(num == null || size < 0){
            return null;
        }
        ArrayList<Integer> list = new ArrayList<Integer>();
        if(size == 0){
            return list;
        }
        ArrayList<Integer> temp = null;
        int length = num.length;
        if(length < size){
            return list;
        }else{
            for(int i = 0; i < length - size + 1; i ++){
                temp = new ArrayList<Integer>();
                for(int j = i; j < size + i; j ++){
                    temp.add(num[j]);
                }
                Collections.sort(temp);
                list.add(temp.get(temp.size() - 1));
            }
        }
        return list;
        
    }
}

暴力求解法，扫描滑动窗口中的每一个数字，并找出其中的最大值。如果滑动窗口的大小为m，则找到窗口内的最大值需要O(k)时间。对于长度为n的数组，总的时间复杂度为O(mn)

思路2：

https://blog.youkuaiyun.com/u010429424/article/details/73692248#commentBox

借助一个辅助队列，从头遍历数组，根据如下规则进行入队列或出队列操作：

0. 如果队列为空，则当前数字入队列

1 . 如果当前数字大于队列尾，则删除队列尾，直到当前数字小于等于队列尾，或者队列空，然后当前数字入队列

2. 如果当前数字小于队列尾，则当前数字入队列

3. 如果队列头超出滑动窗口范围，则删除队列头

这样能始终保证队列头为当前的最大值

以这道题为例：
从头开始遍历数组，我们以下标 i 表示遍历到第几个数字
在开始阶段，队列为空，我们把2入队列，此时i = 0；

i = 1时，num[1] = 3, 由于3大于队列尾2，所以把2移出队列，把3加入队列；

i = 2时，num[2] = 4, 由于4大于3， 所以把3移出队列，把4加入队列，此时滑动窗口刚好经过三个元素，滑动窗口内的最大值就是队列的头元素，也就是4；

i = 3时，num[3] = 2, 因为2小于4，所以把2直接加入队列，此时滑动窗口内的最大值仍然为4；

i = 4时，num[4] = 6, 6大于2和4，所以把2和4移出队列，把6加入到队列中，此时滑动窗口的最大值为6；

i = 5时，num[5] = 2, 因为2小于6，所以把2直接加入队列，此时滑动窗口内的最大值仍然为6；

i = 6时，num[6] = 5, 由于5大于2，所以把2移出队列，把5加入队列中，此时滑动窗口内的最大值仍然为6；

i = 7时，num[7] = 1, 由于6已经不在滑动窗口中了，所以将6从队列头上删除，此时滑动窗口的最大值为5；

遍历结束

那么，如何判断6是否还在滑动窗口中呢，可以通过数组下标进行判断，我们在队列中存储数组的下标而非数值，这样通过判断下标之间的差值是否大于窗口的大小，就可以判断元素是否还在滑动窗口中。

Java 代码如下：

import java.util.*;

public class Solution {
    public ArrayList<Integer> maxInWindows(int[] num, int size) {
        ArrayList<Integer> result = new ArrayList<>();

        if(num == null || num.length == 0 || size == 0 || size > num.length) {
            return result;
        }

        LinkedList<Integer> queue = new LinkedList<>();

        for(int i = 0; i < num.length; i++) {
            if(!queue.isEmpty()){
                // 如果队列头元素不在滑动窗口中了，就删除头元素
                if(i >= queue.peek() + size) { 
                    queue.pop();
                }

                // 如果当前数字大于队列尾，则删除队列尾，直到当前数字小于等于队列尾，或者队列空
                while(!queue.isEmpty() && num[i] >= num[queue.getLast()]) {
                    queue.removeLast();
                }
            }
            queue.offer(i); // 入队列

            // 滑动窗口经过三个元素，获取当前的最大值，也就是队列的头元素
            if(i + 1 >= size) {
                result.add(num[queue.peek()]);
            }
        }
        return result;
    }
}
 
 

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34