【算法修炼之道】——滑动窗口的最大值

 

题目描述：

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

 

题目解析：

1、给定了一个数组和滑动窗口的大小

2、数组的长度包含了滑动窗口的长度；

3、求滑动窗口的最大长度；

 

解题思路：

第一种方法：

1、通过某方法获取最大值，来定义窗口；

2、窗口是滑动的，如果获取的最大值在最大的窗口中；如果窗口滑动出最大值，那就重新获取最大值；

3、如何判定的包含最大值的窗口是最大窗口；

 

第二种方法：

1、使用java的优先队列（也就是堆），也就使用最大堆（PriorityQueue默认是最小堆，构建最大堆只需要在构建时传入一

comparator即可）；

2、在滑动窗口滑动时，将当前元素加入最大堆（PriorityQueue）中，堆顶的元素即是最大值，同时还要判断当元素是否存在于当前窗口中，不存在的话弹出（不符合），最后就把该元素添加入Arraylist；

3、动态的滑动，但是没有考虑到

 

第三种方式：

1、我们可以使用双向队列（Linklist），队列中只存放当前元素的下标，设新来的元素为k，如果前面的元素比k小，直接把前面的删除（因为不可能成为后面窗口的最大值），如果前面的元素比k大，判断是否还在窗口范围内，不在则移除

2、注意：

①先判断当前队列是否为空，如果不空而且当前元素比队列中尾端的元素大，将队列元素的尾端弹出；

②判断队列头元素（存的是下标）是否还在滑动窗口范围中，不在则把头元素移除；

 

代码实现：

第一种实现方式：

package go.jacob.day615;
 
import java.util.ArrayList;
 
public class Demo1 {
	/*
	 * 找出每个窗口里的最大值，每次只要判断最大值是否超出范围，以及新加入的值是否比该值更大
	 */
	public ArrayList<Integer> maxInWindows(int[] num, int size) {

		ArrayList<Integer> result = new ArrayList<Integer>();

               // 特殊情况处理
		if (num == null || size <= 0 || num.length < size)//设置的窗口大小要小于数组
			return result;

		int max = findMaxIndex(num, size, 0);
		result.add(num[max]);//往变换数组添加最大值

             //窗口开始滑动
		for (int i = size; i < num.length; i++) {
			if (num[max] < num[i]){
				max = i;
                        }

			// 如果max不在滑动窗口范围内，也就是说窗口已经划过了max，所以重新找最大值
			if (max <= i - size) {//就算是max是最后一个，也会考虑到；
                     //紧接着max后，获取最大值的下标
				max = findMaxIndex(num, size, i - size + 1);
			}
			result.add(num[max]);
		}
 
		return result;
	}
 
	/*
	 * 查找num指定范围内的最大值的下标
	 */
	private int findMaxIndex(int[] num, int size, int begin) {

		int max = begin;
         //防止超过数组，发生错误；
		int end = (begin + size) > num.length ? num.length : (begin + size);

		for (int i = begin; i < end; i++) {
			if (num[max] < num[i]) {
				System.out.println("num[max]:" + num[max] + " " + "num[i]:" +num[i]);
				max = i;
				System.out.println("max=" + max);
			}
		}
		return max;
	}
 
}

第二种实现方式：

import java.util.ArrayList;
import java.util.Comparator;
import java.util.PriorityQueue;
 
class tmp{
    public tmp() {

    }
 
    public tmp(Integer num,Integer pos) {
        this.pos = pos;
        this.num = num;
    }
 
    public Integer pos;
    public Integer num;
 
    public Integer getNum() {
        return num;
    }
 
    public void setNum(Integer num) {
        this.num = num;
    }
 
    public Integer getPos() {
        return pos;
    }
 
    public void setPos(Integer pos) {
        this.pos = pos;
    }
 
}
 
public class Solution {
    public ArrayList<Integer> maxInWindows(int [] num, int size) {

        ArrayList<Integer> arr = new ArrayList<>();
        if (num==null)
            return arr;
        if (num.length<size||size<=0)
            return arr;

        PriorityQueue<tmp> q = new PriorityQueue<>(100, new Comparator<tmp>() {
            
            public int compare(tmp o1, tmp o2) {
                return o2.num-o1.num;
            }
        });

        for (int i=0;i<size-1;i++)
            q.offer(new tmp(num[i],i));

        for (int i=size-1;i<num.length;i++){

            q.offer(new tmp(num[i],i));
            tmp p = q.peek();
            while (p.getPos()<i-(size-1)){
                q.poll();
                p = q.peek();
            }
            arr.add(p.getNum());
        }
 
        return arr;
 
    }
}

第三种方法：

import java.util.ArrayList;
import java.util.Deque;
import java.util.LinkedList;
 
public class Solution {
    public ArrayList<Integer> maxInWindows(int [] num, int size) {
        ArrayList<Integer> arr = new ArrayList<>();
        if (num==null)
            return arr;
        if (num.length<size||size<=0)
            return arr;
        Deque<Integer> queue = new LinkedList<>();
        for (int i=0;i<num.length;i++){
             while (!queue.isEmpty()&&num[i]>=num[queue.getLast()])
                queue.pollLast();
            while (!queue.isEmpty()&&queue.getFirst()<i-(size-1))
                queue.pollFirst();
            queue.offerLast(i); 
            if (i+1>=size)
                arr.add(num[queue.getFirst()]);
        }
        return arr;
 
    }
}