leetcode：滑动窗口的最大值

5.23 滑动窗口的最大值

题目描述：
给定一个数组 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

解法一：双端队列（最优解法）

1. 将前k个元素入队，也就是将1,3，-1 入队，因为我们要保持最左边的元素为最大元素，则我们可以将1出队，此时队列从[1,3,-1]变为[3,-1]，结果集数组为[3]，继续移动窗口。

1. 将-3入队，此时队列为[3,-1,-3]，则此时最大值依然是3,结果集为[3,3]，继续移动窗口。

3. 将5入队，此时队列为[-1.-3.5]，则我们将左边比5小的元素都出队，则队列变为[5]，则此时5是这个队列的最大值。结果集为[3,3,5]，继续移动窗口。

4. 将3入队，此时队列为[5,3],此时5为队列最大值，结果集为[3,3,5,5]，继续移动窗口。

5. 将6入队，此时队列为[5,3,6]，则将左边比6小的元素出队，队列变为[6],此时队列最大值为6，结果集为[3,3,5,5,6]，继续移动窗口。

6. 将7入队，此时队列为[6,7],此时队列最大值为7，将左边比7小的元素出队，此时队列最大值为7,结果集为[3,3,5,5,6,7] 结束 。

时间复杂度分析：
对于入队和出队操作，时间复杂度为O(1)，一共进行n次，则时间复杂度为O(n）,整体时间复杂度为O(n），比优先队列的解法好。
代码步骤：
1 出队操作(如果队列中保存的数组小标比移动窗口要小，则要移出队列)
2 入队的判断(如果大于队列中的元素，将队列其他元素出队，该元素入队)
3 加入队列(注意，加入的是数组的下标，不是数组值)
4 加入结果集数组
代码：

/**
 * 描述： 滑动窗口最大值
 * <p>
 * 思路： 
 *      解法一： 使用双端队列实现
 *      解法二： 使用优先队列(最大堆)
 * 
 *
 * @author pengjie_yao
 * @date 2019/7/19 20:36
 */
public class MaxSlidingWindow {
 
    public static void main(String[] args) {

        int[] array = new int[]{1, 3, -1, -3, 5, 3, 6, 7};
        int[] maxarray =  dequeueWindow(array,3);

        System.out.println(Arrays.toString(maxarray));
    }
  
    /**
     *  双端队列实现
     * @param array
     * @param k
     * @return
     */
    public static int[] dequeueWindow(int[] array, int k) {
        if (array.length == 0) {
            return new int[]{};
        }
        int[] maxArray = new int[array.length - k + 1];
        Deque<Integer> deque = new ArrayDeque();
        for (int i = 0; i < array.length; i++) {
            // 1.出队操作，当移入元素，则对应的元素位置应该出队
            if (i >= k && i - k + 1 > deque.peek()) {
                deque.remove();
            }

            // 2. 右移入判断，如果左边元素比右边元素小，则全部移出
            while (!deque.isEmpty()  && array[i] > array[deque.peekLast()]) {
                deque.removeLast();
            }
            // 3.将数组下标加入数组
            deque.add(i);
            // 4. 将值放入结果数组
            if (i - k + 1 >= 0) {
                maxArray[i-k+1] = array[deque.peek()];
            }

        }
        return maxArray;

    }
}

解法二： 优先队列(基于最大堆)
我们依然以数组[1,3,-1,-3,5,3,6,7]，且k=3为例进行讲解。
1 将前三个元素加入最大堆中，此时堆顶元素为3，则结果数组[3]

2 窗口继续右移，则此时我们要做的是将1移除堆，并且将-3移入堆并调整堆，此时堆顶元素为3，则数组[3,3]

4 窗口继续右移，元素5入堆，元素3从堆中删除，调整堆，此时堆顶元素为5，则数组为[3,3,5]

5。 窗口继续右移，元素3入堆，元素-1从堆中删除，调整堆，此时堆顶元素为5，则数组为[3,3,5,5]

1. 窗口继续右移，元素6入堆，元素-3出堆，调整堆，此时堆顶元素为6，则数组为[3,3,5,5,6]

窗口 右移，元素7入堆，元素3从堆中删除，调整堆，此时堆顶元素为7，则数组为[3,3,5,5,6,7]
代码如下：

/**
 * 描述： 滑动窗口最大值
 * <p>
 * 思路：
 *      解法一： 使用双端队列实现
 *      解法二： 使用优先队列(最大堆)
 *
 *
 * @author pengjie_yao
 * @date 2019/7/19 20:36
 */
public class MaxSlidingWindow {

    public static void main(String[] args) {

        int[] array = new int[]{1, 3, -1, -3, 5, 3, 6, 7};
        int[] maxarray =  maxSlidingWindow(array,3);

        System.out.println(Arrays.toString(maxarray));
    }

    /**
     * 优先队列： 最大堆
     *
     * @param array
     * @param k
     */
    public static int[] maxSlidingWindow(int[] array, int k) {

        PriorityQueue<Integer> priorityQueue = new PriorityQueue(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });

        // 1.堆数组为空进行判断
        if (array.length == 0) {
            return new int[]{};
        }
        // 结果数组，用来存储返回的结果集数组
        int[] maxArray = new int[array.length - k + 1];
        // 2. 遍历数组,并放入堆中
        for (int i = 0; i < array.length; i++) {
            // 将元素加入堆中
            priorityQueue.offer(array[i]);
            // 3. 当堆中的元素大于或者等于k的时候，将堆顶元素放入结果数组，并删除堆中元素
            if (i + 1 >= k) {
                maxArray[i - k + 1] = priorityQueue.peek();
                priorityQueue.remove(array[i - k+1]);
            }
        }
        return maxArray;
    }

   
}

以上解法，采用优先队列，则时间复杂度为O(logk)，遍历时间复杂度为O(n)，则总时间复杂度为O(nlogk)