239. Sliding Window Maximum多种解法分析

设数组大小为N,滑动窗口大小为K

1. 常规思路

常规思路:遍历数组,每次计算最大值,或者遍历K次,将题目化为两个窗口的方法,时间复杂度为O(N*K), 显然不满足需求。

2. 最大堆

其实做过“寻找n个无穷数中寻找最大的K个数”这题的话,应该比较容易想到,用堆来处理这种“求连续输入的数据中的最值”的题目。思路还是比较像的。
具体思路:
构建一个大小为K的最大堆,每次从堆中取出窗口的最大值,随着窗口往右滑动,需要将堆中不属于窗口的堆顶元素删除。
这里的堆,我们直接使用STL中的优先队列priority_queue(可以理解为另一种形式的堆)
代码如下,复杂度为O(N*logN)

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) 
    {
        vector<int> result;
        priority_queue<pair<int,int>> Q;  //pair.second记录原始数据的序号,从而便于识别最大值是否在当前窗口内,其实也可以只存储编号
        if (nums.size() < k || k < 1)
            return result;
        for (int i = 0; i < k-1; i++) 
            Q.push(pair<int,int>(nums[i],i));
        for (int i = k-1; i < nums.size(); i++) 
        {
            Q.push(pair<int,int>(nums[i],i));
            pair<int,int> p = Q.top(); 
            while(p.second < i-(k-1)) 
            {
                Q.pop();
                p = Q.top();
            }
            result.push_back(p.first);
        }
        return result;        
    }
};

其实在仔细考虑会想到,并不需要一直维护一个大小为K的堆。

3. 集合

class Solution {
public:
   vector<int> maxSlidingWindow(vector<int>& nums, int k) 
   {
       vector<int> result;
       if (k == 0) return result;
       multiset<int> w;
       for (int i = 0, n = nums.size(); i < n; i++) 
       {
           if (i >= k)
                w.erase(w.find(nums[i-k]));
           w.insert(nums[i]);
           if (i >= k-1)
                result.push_back(*w.rbegin());
       }
       return result;
  }       
    
};

3. 双端队列

使用双端队列,队列元素降序排序,队首元素为所求最大值。滑动窗口右移,若出现的元素比队首(最大元素)大,此时清空队列,并将最大值插入队列。若比当前值小,则插入尾部。每次窗口右移的时候需要判断当前的最大值是否在有效范围,若不在,则需要将其从队列中删除。

给出代码,时间复杂度为O(N)

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) 
    {
        vector<int> result;
        deque<int> Q;//队列记录的是编号
        if(nums.size() < k || k <= 0)
            return result;
        for (int i = 0; i < k; i++) 
        {
            while (!Q.empty() && nums[i] > nums[Q.back()]) 
                    Q.pop_back();
            Q.push_back(i);
        }
        for (int i = k; i < nums.size(); i++) 
        {
            result.push_back(nums[Q.front()]);
            while (!Q.empty() && nums[i] >= nums[Q.back()]) Q.pop_back();
            while (!Q.empty() && Q.front() <= i - k) Q.pop_front();
            Q.push_back(i);
        }
        result.push_back(nums[Q.front()]);
        return result;
    }   
    
};

4. 某位大神的O(n)解法

大致思路就是对窗口值对数组进行分段,然后左右分别计算区域内最大值,最后归并。感觉非常smart啊。这个方法值得好好归纳一下,好像之前某些题也有类似的做法。

class Solution {
public:
   vector<int> maxSlidingWindow(vector<int>& nums, int k)
   {
       int n = nums.size();
       vector <int> res;
       if(n == 0)   return res;
       if(k == 1)   return nums;
    
       int left[n]; 
       int right[n]; 
    
       left[0] = nums[0];
       right[n - 1] = nums[n - 1];
       
       for(int i = 0;i < n;i++)
       {
            if(i % k == 0)
            left[i] = nums[i];
            else
            left[i] = std::max(nums[i],left[i - 1]);
        } 
    
    
        for(int i = n - 2;i >= 0;i--)
        {
            if(i % k == 0)
            right[i] = nums[i];
            else
            right[i] = std::max(nums[i],right[i + 1]);
        } 
    
        for(int i = 0; i <= n - k;i++)
        {
            res.push_back(std::max(right[i],left[i + k - 1]));
        }
        return res;
    }
    
};

5. 其他

还有使用栈O(n)解法等,等后续再慢慢看。

参考文献

3 C++ Solutions
C++ Time O(N) Space O(N), Use Max Queue.
Not the best,but the fastest,beat 97%

推荐阅读更多精彩内容