面试题72：滑动窗口的最大值

题目：

给定一个数组和滑动窗口的大小，请找出所有滑动窗口里的最大值。

思路：

方法一：暴力法

窗口大小为K，则每次找到一个窗口最大值的时间复杂度为O（K），总时间复杂度：O(NK)

方法二：

仔细观察，发现窗口滑动其实就是队列先移出一个元素，再添加一个元素，我们可不可以在这个过程中用O（1）的时间来找到队列里最大的那个元素？

我们用两个栈实现过O（1）时间找出栈中最小的元素：面试题25：包含min函数的栈

同时，我们可以用两个栈来实现队列：面试题8：用两个栈实现一个队列

综上可知，我们可以用两个栈来实现队列，由于可以用O（1）时间找到栈的最大值，那么也就可以用O（1）时间找到队列的最大值。

方法三：用最大堆实现

建立一个有K个元素的最大堆，每次插入一个元素的时间复杂度：O(lgK)，获得最大值的时间复杂度为：O（1）

由于优先队列缺省情况下是一个最大堆，我们用优先队列来实现。

#include <iostream>    
#include <vector>    
#include <stack>
#include <queue>
#include <algorithm>  //堆算法
#include <functional> //仿函数
using namespace std;

typedef pair<int, int> Pair;

vector<int> MaxSlidingWindow(vector<int> A, int K)
{
	int size = A.size();
	vector<int> re;
	if (size < K) re;
	for (int i = 0; i <= size-K; i++)
		re.push_back(0);
	priority_queue<Pair> Q;
	for (int i = 0; i < K; i++)
		Q.push(Pair(A[i],i));
	for (int i = K; i < size; i++)
	{
		Pair p = Q.top();
		re[i - K] = p.first;
		while (p.second <= i - K)  //注意这个地方
		{
			Q.pop();
			p = Q.top();
		}
		Q.push(Pair(A[i], i));    //其实堆中的元素最终超过K个
	}
	re[size - K] = Q.top().first;
	return re;
}

int main()
{
	int arr[] = { 2, 3, 4, 2, 6, 2, 5, 1 };
	vector<int>A(arr, arr + 8);
	vector<int> re = MaxSlidingWindow(A, 3);
	for (int i = 0; i < re.size(); i++)
		cout << re[i] << " ";
	cout << endl;
	return 0;
}

上面感觉有问题，时间复杂度肯定超过O（NlgK）

方法四：用deque实现

使用双向队列可以保证，最大值总是在队列首部，且队列中的元素总是从大到小排列（插入元素时，如果尾部的元素比插入的元素小，先将尾部的元素出队列，再插入）。

当遇到比当前滑动窗口最大值更大的值时，先将队列清空，再将新的最大值插入到队列。

每次移动需要判断当前最大值是否在有效范围，如果不是，需将其从队列中删除。

如何判断滑动窗口是否包含一个数字呢？

应该在队列里存入数字在数组里的下标，而不是数值。当一个数字的下标与当前处理的数字的下标之差大于或者等于滑动窗口的大小时，这个数字已经从窗口滑出，可以从队列中删除了。

时间复杂度：O（n）

#include <iostream>    
#include <vector>    
#include <stack>
#include <queue>
#include <algorithm>  //堆算法
#include <functional> //仿函数
using namespace std;

vector<int> MaxSlidingWindow(vector<int> A, int K)
{
	int size = A.size();
	vector<int> re;
	if (size < K) re;
	for (int i = 0; i <= size-K; i++)
		re.push_back(0);
	deque<int> indexQ;
	for (int i = 0; i < K; i++)
	{
		while (!indexQ.empty() && A[indexQ.back()] <= A[i]) indexQ.pop_back();
		indexQ.push_back(i);
	}
	for (int i = K; i < size; i++)
	{
		re[i - K] = A[indexQ.front()];
		while (!indexQ.empty() && A[i] >= A[indexQ.back()]) indexQ.pop_back();
		if (!indexQ.empty() && indexQ.front() <= (i - K)) indexQ.pop_front();
		indexQ.push_back(i);
	}
	re[size - K] = A[indexQ.front()];
	return re;
}

int main()
{
	int arr[] = { 2, 3, 4, 2, 6, 2, 5, 1 };
	vector<int>A(arr, arr + 8);
	vector<int> re = MaxSlidingWindow(A, 3);
	for (int i = 0; i < re.size(); i++)
		cout << re[i] << " ";
	cout << endl;
	return 0;
}