滑动窗口的最大值

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

我整合了一下他们的写法，总结了三种做法
1、暴力法
2、最大堆法
3、双向队列

/*
 * 问题：
 * 给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。
 * 例如，如果输入数组 {2, 3, 4, 2, 6, 2, 5, 1} 及滑动窗口的大小 3，
 * 那么一共存在 6 个滑动窗口，他们的最大值分别为 {4, 4, 6, 6, 6, 5}。
 * 
 */

public class Exer3 {
	public static void main(String[] args) {
		int[] num = {2,3,4,2,6,2,5,1};
		int size = 3;
		
		ArrayList<Integer> list = new Solution3_1().maxInWindow(num, size);
		System.out.println(Arrays.toString(num));
		System.out.println(list);
		
		System.out.println("************************");
		
		ArrayList<Integer> list1 = new Solution3_2().maxInWindow(num, size);
		System.out.println(Arrays.toString(num));
		System.out.println(list1);
		
		System.out.println("************************");
		
		ArrayList<Integer> list2 = new Solution3_1().maxInWindow(num, size);
		System.out.println(Arrays.toString(num));
		System.out.println(list2);
	}
	

}

/*
 * 解法一：暴力法
 * step 1：第一次遍历数组每个位置作为窗口的起点。
 * step 2：从每个起点开始遍历窗口长度，查找其中的最大值。
 * 
 * 时间复杂度：O(nm)其中nnn为数组长度，mmm为窗口长度，双层for循环
 * 空间复杂度：O(1)没有使用额外的辅助空间，暂存的结果res不算入空间开销
 */
class Solution3_1{
	
	public ArrayList<Integer> maxInWindow(int[] num, int size) {
		ArrayList<Integer> list = new ArrayList<>();
		
		//如果窗口大小为0或者窗口大小大于数组长度，则返回空值
		if(size == 0 || size > num.length) {
			return null;
		}
		
		//自己写的，一点都不简洁，或者说思路一样，但是想法过程代码不简洁~~
//		int max;//窗口的最大值
//		int firstIndex = 0;//窗口的首索引
//		int lastIndex;//窗口的尾索引
//		for(; firstIndex <= num.length - size; firstIndex++) {//确定每个窗口的首索引，遍历多个窗口
//			lastIndex = firstIndex + size - 1;//确定每个窗口的尾索引
//			max = num[firstIndex];
//			
//			for(int i = firstIndex; i < lastIndex; i++) {//遍历窗口，找到其中的最大值
//				max = max > num[i + 1] ? max : num[i + 1];
//			}
//			list.add(max);
//		}
		
		//简练的
		for(int i = 0; i < num.length - size + 1; i++) {//确定每个窗口的首索引，遍历多个窗口
			int max = 0;
			for(int j = i; j < i + size; j++) {//遍历窗口，次数为窗口大小减一,找到窗口中最大值
				if(num[j] > max) {
					max = num[j];
				}
			}
			list.add(max);
		}
		return list;
	}
	
}

/*
 * 解法二：用最大堆
 * 
 */
class Solution3_2{
	public ArrayList<Integer> maxInWindow(int[] num, int size){
		ArrayList<Integer> list = new ArrayList<>();
		PriorityQueue<Integer> heap = new PriorityQueue<>((n, m) -> (m - n));
		
		if(size < 1 || num.length < size) {
			return list;
		}
		
		//先把第一个窗口的最大元素获取到
		for(int i = 0; i < size; i++) {
			heap.add(num[i]);
		}
		list.add(heap.peek());
		
		//然后把窗口往后移，最大堆去掉第一个元素，加入后一个元素，获取堆顶元素即最大值
		for(int i = 0, j = size; i < num.length - size; i++, j++) {
			heap.remove(num[i]);
			heap.add(num[j]);
			list.add(heap.peek());
		}
		return list;
	}
}

/*
 * 解法三：应该是效率最高的了。
 * 		 ·时间复杂度：O(n)数组长度为n，只遍历一遍数组
 * 		 ·空间复杂度：O(m)窗口长度m，双向队列最长时，将窗口填满
 * 		用双向队列处理，双向队列是可以在队列两端进行插入和删除操作的队列。
 * 		其主要思想就是遍历一遍数组，用队列存储数据，并且队列的front存储的是当前窗口的最大值，
 * 		每次加入新的元素k的时候，比较k和队列元素的大小：
 * 		1.k > last:后面的元素k大于队列中的元素，说明队列中的该元素再也不可能成为后续窗口的最大值，
 * 			就把该元素从队列rear中删掉，并且在队列中从后往前不断重复这个操作，直到队列为空或比last小
 * 		2.K < last：就把k加入到队列的last中，以备后续使用。
 * 		·获取窗口最大值的时候，需要判断队列front元素是否在窗口内，有可能该元素已经出窗口了，
 * 		所以需要在队列front把该元素删除。
 * 		·还有需要注意的是，队列存储的数据应该是数组元素的下标。
 * 
 */
class Solution3_3{
	
	public ArrayList<Integer> maxInWindow(int[] num, int size){
		ArrayList<Integer> list = new ArrayList<>();
		Deque<Integer> deque = new LinkedList<>();
		if(num.length == 0 || size < 1 || size > num.length) {
			return list;
		}
		
		//处理第一个窗口，并获取第一个窗口的最大值
		for(int i = 0; i < size; i++) {
			while(!deque.isEmpty() && num[i] > num[deque.getLast()]) {
				deque.pollLast();
			}
			deque.addLast(i);
		}
		list.add(num[deque.getFirst()]);
		
		//遍历后续数组，获取后面窗口的最大值
		for(int i = size; i < num.length; i++) {
			//把队列中小于num[i]的元素都删掉
			while(!deque.isEmpty() && num[i] > num[deque.getLast()]) {
				deque.pollLast();
			}
			deque.addLast(i);//然后将num[i]加入到队列中
			
			//判断队列头元素是否在窗口内，否则删掉
			while(!deque.isEmpty() && deque.getFirst() <= i - size) {
				deque.pollFirst();
			}
			//获取窗口最大值
			list.add(num[deque.getFirst()]);
		}
		
		return list;
	}
	
}