Leetcode:239. Sliding Window Maximum （c++)

Problem:

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.

For example,
Given nums = [1,3,-1,-3,5,3,6,7], and k = 3.

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

Therefore, return the max sliding window as [3,3,5,5,6,7].

Note: 
You may assume k is always valid, ie: 1 ≤ k ≤ input array's size for non-empty array.

Follow up:

Could you solve it in linear time?

题目意思：

     给定一个数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口 k 内的数字。滑动窗口每次只向右移动一位。

例如，

给定 nums = [1,3,-1,-3,5,3,6,7]，和 k = 3 。

窗口位置                        最大值
---------------               -----
[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

由此可见，返回最大的滑动窗口为：[3,3,5,5,6,7]。

注意：

你可以假设 k 一直都是有效的，例如：1 ≤ k ≤ 输入数组的大小，输入数组不为空。

进阶：

你能在线性时间复杂度内解决此题吗？

分析：

      假设nums的长度n，正常的思维是每次判断窗口内最大值，一共判断（n - k)次，每次个窗口内有k个元素，因此复杂度为

(n - k) * k ; 这样就不满足线性时间复杂度，我们来看看正常思维的解法是不是有重复操作，比如判断完第一个窗口的最大值，之后第二个窗口时，发现第一个窗口与第二个窗口相交的坐标重复判断了，那因此我们用一个双向链表来保存上一次窗口留下的最大值，次大值。。。链表首第一个元素为上一次窗口判断的最大值，尾第一个元素为最小值，如果来了一个nums的新元素，我们有四个操作：（链表存的是nums的index,也就是1，2，3，4....）

（1）如果这个元素比链表首第一个元素大（也就是比上一个窗口最大值大），我们就清空链表（为什么清空链表呢，因此链表中的历史元素都没有这个元素大，所以没有存在的价值了，随着时间的进行，窗口的移动，下一个元素只会和这个最大值进行判断）；

（2）如果这个元素比链表首第一个元素小，我们就从链表尾进行判断，如果比链表尾元素大，删掉链表尾元素，重复次操作，直到比链表尾元素小；（为什么要删掉那些小元素呢，因为来了个新元素，这个新元素如果比历史的小元素大的话，随着时间的推进，也就是窗口的移动，那些历史的小元素没有用处，所以删掉即可；那为什么遇到队列尾部大元素就停止了呢，因此我们不确定在下一个新元素进来的时候，这个比当前值大的元素是否脱离了窗口，因此要保留，所以就有了第三个操作，即判断比当前值大的元素是否脱离了窗口，如果脱离了窗口的话，那么这个次大的元素就上台了）；

（3）如果链表首元素的index脱离的滑动窗口，那么删掉链表首元素；

（4）进行完上面三次操作后，我们将这个元素从链表尾入表。

重复上面四个操作，直到遍历整个nums。

双向链表实现，由于每个元素只判断一次或两次，因此时间复杂度o(n)到o(2n）之间，为线性复杂度。

接下来就是代码（c++）：

class Solution {

public:

    vector<int> maxSlidingWindow(vector<int>& nums, int k) {

        vector<int> ans;

        if(nums.size() == 0) return ans;

        list<int> dbList;

        for(int i = 0; i < nums.size(); i++){

            if(!dbList.empty() && nums[dbList.front()] < nums[i])               //操作一

                dbList.clear();

            while(!dbList.empty() && nums[dbList.back()] < nums[i])         //操作二

                dbList.pop_back();

            if(!dbList.empty() && dbList.front() == i - k)                          //操作三

                dbList.pop_front();

            dbList.push_back(i);

            if((i+1)>=k)

                ans.push_back(nums[dbList.front()]);

        }

        return ans;

    }

};