《leetCode》：Sliding Window Maximum

题目

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.

Follow up:
Could you solve it in linear time?

Hint:

How about using a data structure such as deque (double-ended queue)?
The queue size need not be the same as the window’s size.

Remove redundant elements and the queue should store only elements that need to be considered.

思路一

最简单的方法就是：从头到尾的滑动求最大值。

实现代码如下：

     public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums==null||nums.length<k||k<1){
            return new int[0];
        }
        int len = nums.length;
        int[] res = new int[len-k+1];
        for(int i=0;i<len-k+1;i++){
            res[i]=maxValue(nums,i,i+k-1);
        }
        return res;
    }

    private int maxValue(int[] nums, int begin, int end) {
        if(nums==null||begin>end){
            return Integer.MIN_VALUE;
        }
        int max = Integer.MIN_VALUE;
        for(int i=begin;i<=end;i++){
            if(max<nums[i]){
                max = nums[i];
            }
        }
        return max;
    }

时间复杂度为O(kN)，本来以为这种方法不会AC，没想到居然给AC了。

改进

思路：由于第i个滑动窗口的最大值和三个因素有关系，maxSlide[i-1]、nums[i+k-1]、nums[i-1]；其中maxSlide[i-1]表示第i-1个滑动窗口的最大值，因此，会有如下几种情况产生

1、如果nums[i+k-1]>=maxSlide[i-1]，则maxSlide[i]=nums[i+k-1]；

2、如果nums[i+k-1]

   public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums==null||nums.length<k||k<1){
            return new int[0];
        }
        int len = nums.length;
        int[] res = new int[len-k+1];
        for(int i=0;i<len-k+1;i++){
            if(i==0){
                res[i]=maxValue(nums,i,i+k-1);
            }
            else{
                int temp = nums[i+k-1];
                int pre = nums[i-1];
                res[i] = (temp>=res[i-1]?temp:
                    (res[i-1]!=pre?res[i-1]:maxValue(nums,i,i+k-1)));
            }

        }
        return res;
    }

    private int maxValue(int[] nums, int begin, int end) {
        if(nums==null||begin>end){
            return Integer.MIN_VALUE;
        }
        int max = Integer.MIN_VALUE;
        for(int i=begin;i<=end;i++){
            if(max<nums[i]){
                max = nums[i];
            }
        }
        return max;
    }

对比改进后的AC结果，发现运行时间从52ms减少到7ms了。