Sliding Window Maximum（维护一个单调双端队列）

Given an array 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:

Input: nums = [1,3,-1,-3,5,3,6,7], and 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

/* deque double end queue  队头front  队尾back
 *  左      右       eg 给定{7, 5, 16, 8}, 7是最早读入的
 *front    end
 * 7  5  16  8
 *
 * 本题是维护了一个单调递减的双端队列   队列中存放的是数组下标而非值（方便判断窗口的位置）
 * 队列中最大的位置在队头 需要滑动时  即把队头出队并记录
 * 队尾为了保证单调性 即确保队列中元素都比当前元素值大  然后当前元素对应的下标才能入队
 *
 *
 * 我们用双向队列可以在O(N)时间内解决这题。当我们遇到新的数时，将新的数和双向队列的末尾比较，
 * 如果末尾比新数小，则把末尾扔掉，直到该队列的末尾比新数大或者队列为空的时候才住手。这样，
 * 我们可以保证队列里的元素是从头到尾降序的，由于队列里只有窗口内的数，所以他们其实就是窗口内第一大，
 * 第二大，第三大...的数。保持队列里只有窗口内数的方法和上个解法一样，也是每来一个新的把窗口最左边的扔掉，
 * 然后把新的加进去。然而由于我们在加新数的时候，已经把很多没用的数给扔了，这样队列头部的数并不一定是窗口最左边的数。
 * 这里的技巧是，我们队列中存的是那个数在原数组中的下标，这样我们既可以直到这个数的值，也可以知道该数是不是窗口最左边的数。
 * 这里为什么时间复杂度是O(N)呢？因为每个数只可能被操作最多两次，一次是加入队列的时候，一次是因为有别的更大数在后面，
 * 所以被扔掉，或者因为出了窗口而被扔掉。
 * */
class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> ret;
        deque<int> q;
        for(int i=0;i<nums.size();i++){
            // 队列头部的数并不一定是窗口最左边的数 记队头下标为f  i-f=k 时代表窗口拓展了
            if(q.front() == i - k)  q.pop_front();

            // 确保插入新元素后 队列仍未单调递减
            while(!q.empty() && nums[q.back()] < nums[i])   q.pop_back();
            q.push_back(i);

            // 减1原因是i从0开始
            // 7 3 4 5 6 7 8
            // x x x     则从4所在的位置开始要记录（此时第一次拥有完整的窗口）
            if(i >= k-1)    ret.push_back(nums[q.front()]);
        }
        return ret;
    }
};