题目描述：
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.
分析：
开始觉得题目的形式很眼熟，感觉应该用Max Heap解。但是显然Max Heap的复杂度是O(n*logK)，事实上应该用类似与插入排序的手法，利用双向队列求解。遍历数组，每遇到一个数就与队列的末尾进行比较，若队列末尾的数小于当前数，则队列末尾退出队列，如此往复，知道队列为空，或者队列里的数都大于当前数，最后插入当前数。由此可知，队列中的数是按照从队首到队尾从大到小排序而成。我们每次将窗口往前移动一格，就插入一个数，并且在队首取得窗口的最大值。不过，这里需要注意一点，队首的数可能已经位于窗口之外了！因此，我们用了一个比较tricky的手法，那就是在队列中插入的并不是具体元素的值，而是元素在数组中的位置，这样我们在遍历数组的过程中就能判断队列中的数是否仍然在队列中了。若我们在取最大值时，发现队首的元素已经在窗口之外了，则将其弹出，直到找到仍在窗口内的队首元素为止。最后，不断循环上述过程，即可得到问题的解。
但是，问题是为什么上面说的解法是O（n）的复杂度呢，插入排序的思想和上面说的是完全一致的，可是复杂度却是O（n*n）。其实我们可以发现，上述解法与插入排序不同的是，不存在重复比较。在插入新元素时，比新元素小的元素都退出队列了，因为它们不可能是之后窗口的解。在取最大值时，所有不再窗口内的元素也全都弹出队列了。最终我们可以发现，每次比较都伴随着插入或者删除元素，而元素个数为n，因此全局的操作最多可能分别只有n次的插入，删除，比较操作，所以复杂度为O（n）。（第一次用双向队列求解问题，感觉还是挺神奇的）
代码：
class Solution {
public:
vector<int> maxSlidingWindow(vector<int>& nums, int k) {
deque<int> d;
vector<int> ans;
if(nums.size()==0) {
return ans;
}
d.push_front(0);
for(int i=1;i<k;i++) {
while(!d.empty()&&nums[d.back()]<nums[i]) {
d.pop_back();
}
d.push_back(i);
}
ans.push_back(nums[d.front()]);
for(int i=k;i<nums.size();i++) {
while(!d.empty()&&nums[d.back()]<nums[i]) {
d.pop_back();
}
d.push_back(i);
while(d.front()<=i-k) {
d.pop_front();
}
ans.push_back(nums[d.front()]);
}
return ans;
}
};