剑指offer59-I.滑动窗口的最大值

题目：给定一个数组 nums 和滑动窗口的大小 k，请找出所有滑动窗口里的最大值。

思路：我刚开始是使用的是优先队列做，写完之后有4个测试案例没有通过，后来发现，我在删除队列元素的时候只考虑了当删除的数组的元素等于队列栈顶元素时，就删除队列的元素；这样考虑会出现这样的问题，比如这个测试案例：[9,10,9,-7,-4,-8,2,-6]
5
当前面出现一样的元素时，只会删除一个最大的，因此后面还是会有一样的；所以我们需要同时在队列中删除数组中删除的那个元素。

class Solution {
    int temp = 0;
    public int[] maxSlidingWindow(int[] nums, int k) {
        Queue<Integer> queue = new PriorityQueue<Integer>((x,y)->(y-x));//大顶堆，大的出
        int left = 0;
        int right = k-1;
        List<Integer> list = new ArrayList<Integer>();
        if(nums.length == 0) return new int[0];
        for(int i=left;i<=right-1;i++){
                queue.add(nums[i]);
           }
        while(right<=nums.length-1){
            queue.add(nums[right]);
            if(nums[left] == queue.peek()){
                list.add(queue.poll());
            }else{
                list.add(queue.peek());
                queue.remove(nums[left]);
            }
            left++;
            right++;
            
        }
        int[] res = new int[list.size()];
        for(int i=0;i<list.size();i++){
            res[i] = list.get(i);
        }
        return res;
    }
}

优化之后：

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if (nums == null || nums.length == 0 || k <= 0)
            return new int[0];

        PriorityQueue<Integer> queue = new PriorityQueue<Integer>((a, b) -> b - a);
        for (int i = 0; i < k; i++){
            queue.add(nums[i]);
        }

        int[] res = new int[nums.length - k + 1];
        int j = 0;
        res[j++] = queue.peek();

        for (int i = k; i < nums.length; i++){
            queue.remove(nums[i - k]);//从数组前面开始删除元素
            queue.add(nums[i]);
            res[j++] = queue.peek();
        }

        return res;
    }
}

然而这样写时间复杂度太高，运行时间达到130ms，虽然能通过但是显然是不可取的。

第二种方法：单调队列;基本思路就是添加数据时判断一下队列中的数，当队列中的数小于添加的数就删除这个数，保证队列是单调递减的；其次，当数组删除的那个数等于队列头的那个数时，需要同时删除。

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums.length == 0) return new int[0];
        LinkedList<Integer> deque = new LinkedList<Integer>();
        int index = 0;
        int[] res = new int[nums.length-k+1];
        for(int i=0;i<k;i++){//未形成队列
            while(!deque.isEmpty()&&deque.peekLast()<nums[i]){
                deque.removeLast();
            }
            deque.add(nums[i]);
        }
        res[index] = deque.peekFirst();
        for(int i=k;i<nums.length;i++){//形成队列
            if(deque.peekFirst() == nums[i-k]){//如果数组中删除的元素和队列头的一样就删除
                deque.removeFirst();
            }
            while(!deque.isEmpty() && deque.peekLast()<nums[i]){
                deque.removeLast();
            }
            deque.addLast(nums[i]);
            res[++index] = deque.peekFirst();
    }
    return res;
    }
}