滑动窗口最大值（暴力优化+双端队列）

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

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

示例 1：

示例 2：

解题思路：
1、 利用双指针滑动窗口，通过两层循环暴力破解。left指针作为窗口的左端点，right作为右端点，两个指针之间的距离为 right - left = k - 1。这个思路比较简单，下面直接附上代码（代码没有加注释，因为最后爆了，没用通过，不推荐）：

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        int len = nums.length;
        int max = Integer.MIN_VALUE;
        if(len <= k){
            for(int num: nums){
                max = Math.max(max,num);
            }
            int[] ans = new int[1];
            ans[0] = max;
            return ans;
        }
        int[] ans = new int[len - k + 1];
        int left = 0;
        int right = k - 1;
        while(left < len - k + 1){
            for(int i = left; i <= right ;i++){
                 max = Math.max(max,nums[i]);
            }
            ans[left] = max;
            max = Integer.MIN_VALUE;
            left++;
            right++;
        }
        return ans;
    }
}

结果：

从上述结果可以看到，暴力破解在本题中通过率其实已经很高了，虽然没有百分百通过，下面就看一下能不能在此基础上进一步优化。

优化： 优化的时候我们先想到的就是边界值，这题滑动窗口每次滑动都会有一个新元素加入和旧元素滑出，而我们要求的是最大值，因此可以从滑出的元素中切入。结合题意滑出的元素无非扮演两种角色：
1、当前窗口的最大值
2、普通元素
因此我们分两种情况判断：如果滑出的元素是当前窗口的最大值，下一个窗口仍然要遍历整个窗口；如果滑出的是普通元素，下一个窗口的最大值只有两种可能，就是当前窗口最大值或者新加入的元素。优化思路基本已经明确了，下面是优化后的代码（具体注释在代码中）。

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        int len = nums.length;
        int max = Integer.MIN_VALUE;
        //如果数组没有k的值大，则直接遍历数组找到最大值，存到数组中进行返回
        if(len <= k){
            for(int num: nums){
                max = Math.max(max,num);
            }
            int[] ans = new int[1];
            ans[0] = max;
            return ans;
        }
        int[] ans = new int[len - k + 1];
        int left = 0;
        int right = k - 1;
        boolean flag = true;
        while(right < len)
        {   //如果前一个窗口的最大值是前一个窗口的左端点
            if(flag){
                for(int i = left; i <= right ;i++){
                    max = Math.max(max,nums[i]);
                }
            }
            //如果前一个窗口的最大值不是前一个窗口的左端点
            //那么前面这个max肯定位于当前窗口，只需要把新加入的nums[right]与其比较取最大值
            else{
                max = Math.max(nums[right],max);
            }
            //最大值存到答案数组中
            ans[left] = max;
            //如果最大值是窗口左端点
            //flag设置为true，并且因为要重新遍历，max重置为最小值
            if(max == nums[left]){
                flag = true;
                max = Integer.MIN_VALUE;
            }
            else{
                flag = false;
            }
            left++;
            right++;
        }
        return ans;
    }
}

假如数组长度为n，滑动窗口大小为k。
时间复杂度：该方法使用了两层循环，尽管后面代码实现了优化，但是时间复杂度都为O(n*k)。
空间复杂度：空间复杂度为O(1)，答案返回数组不计算。

2、 双端队列
该方法的核心思想是元素从左往右滑动的过程中，当前元素的值如果大于左边元素的值，左边的元素就会被丢弃。这点应该比较好理解，对于当前位置的元素，所有包含了当前元素的窗口有两种可能。
1、窗口还包含当前元素左边的某些元素，但是由于它们都没有当前元素大，不影响最大值结果，可以舍弃。 2、窗口不包含当前元素左边的元素，那肯定也没影响了，可以舍弃。
而对于当前元素的右边元素（也就是待会要加入到队列的元素）。当它比当前元素大，就会淘汰当前元素（这一点其实就是上面的分析结果）；需要注意的就是，当它比当前元素小时，也要进入队列 （因为会有窗口包含右边元素而不包含当前元素）。

关键点： 在队列中的元素，如何判断它们和是否在当前滑动窗口内？
队列中保存数组下标，而不是保存元素本身。比如窗口范围为[ i - k + 1，i ]，我们通过下标就可以知道是否在窗口内，并且可以取得元素值。
淘汰元素过程中，需要比较大小，踢除小的，保留大的，因此要取得最小值；同时窗口值要取得最大值，也要从队列中获取，怎样在队列实现这种操作？
首先在队列中进行单调排序，进来的时候比较最小值，同时为了方便最大值取出，就需要从另一端获得最大值，因此需要实现单调的双端队列。
时间复杂度：

时间复杂度：只遍历了依次数组，因此是O(n)。
空间复杂度：建立了一个辅助队列，空间复杂度为O(k)，答案返回数组不计算。

答案代码（详细注释）：

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        int len = nums.length;
        Deque<Integer> dq = new ArrayDeque<>();
        int[] ans = new int[len - k + 1];

        int i = 0;
        int right = k - 1;

        while(i < len){
            //当前队列中最大值的下标，是否在窗口内
            while( dq.size()!= 0 && dq.peek() < i - k + 1) dq.poll();
            //新来的值会踢除队列中对应下标数组中比它小的值（因为现在往右滑动过程中，包含这些值的窗口肯定也包含新值，因此旧的且小的值将被淘汰）
            while( dq.size()!= 0 && nums[dq.peekLast()] < nums[i] ) dq.pollLast();
            //新值对应下标加入到队列中（新值把比它小的值淘汰，虽然队列中还有比它大的值，但是窗口往有移动的过程中，这些较大的值到达不了，因此不能进行比较，所以新值的下标需要先加入到队列中）
            dq.offer(i);
            //滑动窗口到达目标窗口大小，开始存储窗口最大值
            //注意这里要使用peek()方法，不然最大值就被踢掉
            if( i >= k - 1){
                ans[i - k + 1] =nums[dq.peek()];
            }
            i++;
        }
        return ans;
    }
}

附（双端队列的使用方法，该部分从网上整理）：

双端队列分类：
LinkedList 大小可变的链表双端队列，允许元素为插入null。
ArrayDeque 大下可变的数组双端队列，不允许插入null。
ConcurrentLinkedDeque 大小可变且线程安全的链表双端队列，非阻塞，不允许插入null。
LinkedBlockingDeque 为线程安全的双端队列，在队列为空的情况下，获取操作将会阻塞，直到有元素添加。