LeeCode（ 优先队列）239_ 滑动窗口最大值

LeeCode（ 优先队列）239_ 滑动窗口最大值

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

返回滑动窗口中的最大值。

示例 1：

输入：nums = [1,3,-1,-3,5,3,6,7], k = 3
输出：[3,3,5,5,6,7]
解释：
滑动窗口的位置 最大值

---

[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
示例 2：

输入：nums = [1], k = 1
输出：[1]
示例 3：

输入：nums = [1,-1], k = 1
输出：[1,-1]
示例 4：

输入：nums = [9,11], k = 2
输出：[11]
示例 5：

输入：nums = [4,-2], k = 2
输出：[4]

提示：

1 <= nums.length <= 105
-104 <= nums[i] <= 104
1 <= k <= nums.length

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/sliding-window-maximum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路：
推算出窗口的数量为nums.length-k+1

方法一:优先队列

• 对于找最大值，我们可以很快想到优先队列,其中的大根堆可以帮我们实时维护一组元素的最大值。
• 初始:我们将K个元素放入到优先队列中,此时堆顶便是第一个最大值。
• 移动窗口:当我们移动窗口时,将对应的下一个元素加入优先队列即可,此时的最大值能已经不在当前窗口所包括的区域内,于是删除该元素,直到找到的最大值处于窗口区域内。
• 以为要实时删除优先队列中不处于窗口的元素,于是我们把每个元素放入优先队列中时应同时放入它所对应的下标。

Java代码:

import java.util.Comparator;
import java.util.PriorityQueue;

public class 滑动窗口最大值 {
	public int[] maxSlidingWindow(int[] nums, int k) {
		int num = nums.length;
		PriorityQueue<int[]> pq = new PriorityQueue<int[]>(new Comparator<int[]>() {
			@Override
			public int compare(int[] pair1, int[] pair2) {
				// TODO Auto-generated method stub
				return pair1[0] != pair2[0] ? pair2[0]-pair1[0] : 0;
			}
		});
		
		for(int i=0;i<k;i++){
			pq.offer(new int[]{nums[i],i});
		}
		
		int[] ans = new int[num-k+1];
		ans[0] = pq.peek()[0];
		for(int i = k;i < num;i++){
			pq.offer(new int[]{nums[i],i});
			while(pq.peek()[1]<=i-k){
				pq.poll();
			}
			ans[i-k+1]=pq.peek()[0];	
		}
		
		return ans;
	}
}

方法二:单调队列
我们维护一个队列deque里面将数组的元素的下标按照它们对应的值单调递减排列。
每次往队列放值时我们只要考虑,该值有没有比队列尾的值大，如果没有的话它必不可能成为最大值。如果比队列尾的值大则将队列尾的值弹出，接着进行判断，直到队列为空或者该值小于目前队列尾的值，将该值放入。

将队列头(对应的最大值的下标)取出判断是否越界(下标不在窗口内),得到答案。

import java.util.Comparator;
import java.util.Deque;
import java.util.LinkedList;
import java.util.PriorityQueue;

public class 滑动窗口最大值 {
	 public int[] maxSlidingWindow(int[] nums, int k) {
		 int n = nums.length;
		 Deque<Integer> deque = new LinkedList<>();
		 
		 //初始化队列
		 for(int i=0;i<k;i++){
			 while(!deque.isEmpty() && nums[i]>nums[deque.peekLast()]){
				 deque.pollLast();
			 }
			 deque.offerLast(i);
		 }
		 
		 int[] ans = new int[n-k+1];
		 
		 ans[0] = nums[deque.pollFirst()];
		 
		 for(int i=k;i<n;i++){
			 while(!deque.isEmpty() && nums[i]>nums[deque.peekLast()]){
				 deque.pollLast();
			 }
			 deque.offerLast(i);
			 
			 while(deque.peekFirst()<=i-k){
				 deque.pollFirst();
			 }
			 
			 ans[i-k+1] = nums[deque.peekFirst()];
		 }
		return ans;
	 }
}