239. Sliding Window Maximum （滑动窗口最大值， 大根堆or 单调队列）

 

You are given an array of integers nums, there is a sliding window of size k which is moving from the very left of the array to the very right. You can only see the k numbers in the window. Each time the sliding window moves right by one position.

Return the max sliding window.

 

Example 1:

Input: nums = [1,3,-1,-3,5,3,6,7], k = 3
Output: [3,3,5,5,6,7]
Explanation: 
Window position                Max
---------------               -----
[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

方法一：优先队列(堆)

对于「最大值」，我们可以想到一种非常合适的数据结构，那就是优先队列（堆），其中的大根堆可以帮助我们实时维护一系列元素中的最大值。

import heapq
class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:

        q = [(-nums[i],i) for i in range(k)]
        n = len(nums)
        heapq.heapify(q)
        
        res = [-q[0][0]]
        for i in range(k,n):
            heapq.heappush(q,(-nums[i],i))
            while  q[0][1] <= i - k :
                heapq.heappop(q)
            res.append(-q[0][0])
        return res

 

 

 

class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        n = len(nums)
        q = collections.deque()
        for i in range(k):
            while q and nums[i] >= nums[q[-1]]:
                q.pop()
            q.append(i)

        ans = [nums[q[0]]]
        for i in range(k, n):
            while q and nums[i] >= nums[q[-1]]:
                q.pop()
            q.append(i)
            while q[0] <= i - k:
                q.popleft()
            ans.append(nums[q[0]])
        
        return ans

 

 

 

 

 

 

 法1：

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> res;
        priority_queue<pair<int, int>> q;
        for(int i = 0; i < k;++i) {
            q.push({nums[i],i});
        }
        res.push_back(q.top().first);

        for(int i = k;i < nums.size();++i) {
            q.push({nums[i],i});
            while(q.top().second + k <= i) {
                q.pop();
            }
            res.push_back(q.top().first);
        }
        return res;
    }
};

 

 

法二：

 

https://labuladong.gitbook.io/algo/mu-lu-ye-1/mu-lu-ye-2/dan-tiao-dui-lie

 

首先，明确一个概念，单调队列是在队列中所有的元素都是单调的，要么单调增，要么单调减，新增元素时到队尾，此时队列不符合单调性就将队尾元素出队，直到队列单调或空。

class MonotonicQueue {
private:
    deque<int> data;
public:
    void push(int n) {
        while (!data.empty() && data.back() < n) 
            data.pop_back();
        data.push_back(n);
    }
    
    int max() { return data.front(); }
    
    void pop(int n) {
        if (!data.empty() && data.front() == n)
            data.pop_front();
    }
};

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
    MonotonicQueue window;
    vector<int> res;
    for (int i = 0; i < nums.size(); i++) {
        if (i < k - 1) { //先填满窗口的前 k - 1
            window.push(nums[i]);
        } else { // 窗口向前滑动
            window.push(nums[i]);
            res.push_back(window.max());
            window.pop(nums[i - k + 1]);
        }
    }
    return res;
    }
};

 

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
    deque<int> q;
    vector<int> res;
    for (int i = 0; i < nums.size(); i++) {
        // push
        while(!q.empty()&& q.back() < nums[i]) {
            q.pop_back();
        }
        q.push_back(nums[i]);
        if (i >= k - 1) { //前k - 1 已经填满
            res.push_back(q.front());
            // pop
            if(!q.empty() && nums[i - k + 1]== q.front()) {
                q.pop_front();
            }
        }
    }
    return res;
    }
};