239. 滑动窗口最大值

题目

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

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

 

进阶：

你能在线性时间复杂度内解决此题吗？

 

示例:

输入: 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

思路

利用单调队列的思想,详见单调队列详解.主要的思想是:新元素从对尾入队,应保证队列元素的单调性(此题为单调减),如果新元素大于队尾元素,则将队尾元素出队,直到无元素小于新元素为止,最后将新元素入队.

单调队列的head保持为当前滑动窗口最大的元素(通过检查head元素的index与当前遍历的下标的差值,检测head元素是否在滑动窗口内部,不在则清除滑动窗口),每个新元素从尾部进入单调队列.

代码

代码采用数组作为单调队列的实现,数组元素类型Node,保存了元素的值和下标,本题亦可采用双向链表来实现单调队列(单调队列存在从队尾删除元素的操作,单向链表并不方便).使用数组作为单调队列的好处在于,无需双向链表的维护前后节点的操作,通过头指针(head),尾指针(tail)和len字段,利用循环链表的思想即可简洁的实现单调队列.

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(k==0||nums.length==0) return new int[0];
        int[] a = nums;
        if (a.length - k + 1 < 0) return null;                                             
        int[] result = new int[a.length - k + 1];                                          
        Node[] t = new Node[k];                                                            
        int head = 0, tail = k-1;                                                          
        int len = 0;                                                                       
        for (int i = 0; i < a.length; i++) {                                               
            while (len > 0 && i - t[head].index >= k) {                                    
                head = (head + 1) % k;                                                     
                len--;                                                                     
            }                                                                              
            while (len > 0 && t[tail].val <= a[i]) {                                       
                tail = (tail - 1 + k) % k;                                                 
                len--;                                                                     
            }                                                                              
            tail = (tail + 1) % k;                                                         
            t[tail] = new Node(a[i], i);                                                   
            len++;                                                                         
            if(i>=k-1){                                                                    
                result[i-k+1] = t[head].val;                                               
            }                                                                              
        }                                                                                  
        return result;                                                                                                                          
    }

    private static class Node {                     
        int val;                                    
        int index;                                  
                                                    
        public Node(int val, int index) {           
            this.val = val;                         
            this.index = index;                     
        }                                           
    }                                               
}