滑动窗口的最大值

滑动窗口的最大值

描述
给定一个长度为 n 的数组 num 和滑动窗口的大小 size ，找出所有滑动窗口里数值的最大值。

例如，如果输入数组{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]}。

窗口大于数组长度或窗口长度为0的时候，返回空。

数据范围：1≤n≤10000，0≤size≤10000，数组中每个元素的值满足 ∣val∣≤10000
要求：空间复杂度 O(n)，时间复杂度 O(n)

示例1
输入：
[2,3,4,2,6,2,5,1],3

返回值：
[4,4,6,6,6,5]

示例2
输入：
[9,10,9,-7,-3,8,2,-6],5

返回值：
[10,10,9,8]

示例3
输入：
[1,2,3,4],5

返回值：
[]

方法一：暴力方法

根据题目描述，我们很容易想到暴力方法。并且也很轻松的就可以写出来。如果数组的大小是n，窗口的大小是size，那么窗口的数量就是 n - size + 1.
算法步骤如下：

• 枚举每个窗口的左边界 i
• 根据窗口的左边界i可以对应计算出右边界j
• 遍历窗口，计算出最大值

代码如下：

class Solution {
public:
    vector<int> maxInWindows(const vector<int>& num, unsigned int size) {
        vector<int>ret;
        int sz=num.size();
        if(size>sz || size==0) return ret;
        for(int i=0;i<=sz-size;++i){
            int maxval=num[i];
            for(int j=i+1;j<i+size;++j){
                if(num[j]>maxval) maxval=num[j];
            }
            ret.push_back(maxval);
        }
        return ret;
    }
};

• 时间复杂度： O(n*k), 其中n为数组大小，k为窗口大小
• 空间复杂度： O(1)，存结果必须要开的数组不算入额外空间

方法二：单调队列(双端)

思路：

• 考虑到在一个窗口中如果第i个元素num[i],当下一个元素num[i+1]比num[i]大的话，那么num[i]就一定不是当前窗口的最大值，如果用一个容器来装每个窗口的最大值的话，则此时可以将num[i]删掉，而把num[i+1]加入到这个容器中；
• 但是问题是：当前窗口遍历每个元素时，将大的留在容器中，当窗口随着遍历序列的元素后移而后移改变时，如何在窗口移动的过程中，保证容器里面用来比较的元素不是“过期”（即非当前窗口）元素呢，如果是过期元素那么还需要删除，那么容器就必须还要考虑到序列和方向性，保证能从两头来删除或添加元素；
• 随着对序列的从前往后遍历，我们考虑用一个双端队列deque来做存储最大值的容器，当num[i+1]与num[i]比较时的从容器的末尾来pop_back(),在添加元素时也是从末尾去push_back，而当有元素过期时，从容器头部将其删除即pop_front()，而且在删除之前还应将容器头部元素deque.front()写入最后的返回结果中；由于我们只能遍历num这个序列，这样考虑我们可以将num的下标i作为元素来操作；

综合以上几点代码如下：

class Solution {
public:
    vector<int> maxInWindows(const vector<int>& num, unsigned int size) {
        int sz=num.size();
        int ssz=(int)size;
        vector<int> ret;
        deque<int> due;
        if(ssz>sz || ssz==0) return ret;//当窗口大小大于序列长度或窗口大小为0时返回空
        for(int i=0;i<sz;++i){
            if(due.empty()){
                due.push_back(i);//当容器为空时，push_back()当前元素
            }
            else {
                while(!due.empty() && num[i]>num[due.back()]){
                    due.pop_back();//当前元素大于队列末尾元素时，删除末尾元素
                }
                due.push_back(i);//当前元素小于队列末尾元素，push_back()
            }
            if(i-ssz>=due.front()){//队列头元素下标小于窗口左边界时即“过期”
                due.pop_front();//从头部删除队列“过期元素”
            }
            if(i+1>=ssz){//序列遍历到窗口大小减一的下标时窗口开始移动，队列头部元素开始写入
                ret.push_back(num[due.front()]);
            }
        }
        return ret;
    }
};

• 时间复杂度： 遍历一遍序列即可，因此时间复杂度为O(N)
• 空间复杂度： 用了一个双端队列存储K个元素，K为窗口大小，因此为O(K).