Java 版本答案
public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums.length==0) return new int[0];
        
        int[] res = new int[nums.length - k + 1];
        Deque<Integer> deque = new ArrayDeque<>();
        
        for(int i=0;i<nums.length;i++) {
            // 删除队列中小于窗口左边下标的元素
            if(i >= k && i - k + 1 > deque.peek()) deque.remove();
            
            // 从队列右侧开始, 删除小于nums[i] 的元素
            while(!deque.isEmpty() && nums[deque.peekLast()] < nums[i])
                deque.removeLast();
            
            deque.add(i);
            
            // 队列左侧是最大值,加入结果
            if(i - k + 1 >= 0)
                res[i - k + 1] = nums[deque.peek()];
        }
        return res;
    }

看了半天终于明白了，这个题目的关键在于队列里面存储的是下标而不是元素值，这样可以解决窗口滑动的问题. 写了一个java版本的实现.
public static ArrayList<Integer> kSlidingMax2(int k,int []a){
        ArrayList<Integer> result = new ArrayList<>();
        Queue<Integer> queue = new LinkedBlockingQueue<>(k);
        queue.add(0); //将数据第一个元素先放入队列.
        for(int i=1;i<a.length;i++){
            //判断最大元素是否超出滑动窗口,若超出则将最大元素移出队列.
            //可以保证队列内的元素始终小于等于k个. 这个才是整个算法的关键
            //注意队列里面放的是元素的下表而不是元素的值.
            if(queue.peek()<i-k+1){
                queue.remove();
            }
            //新的元素要a[i]要入队，入队之前先清除比a[x]小的元素
            Iterator<Integer> it = queue.iterator();
            while (it.hasNext()){
                if(a[it.next()]<a[i]){
                    it.remove();
                }
            }
            queue.add(i);

            if(i>=k-1){
                result.add(a[queue.peek()]);
            }
        }
        return result;
    }

我在写此类算法题时候，使用的是JS语言， 所以直接编写如下的代码：
var maxSlidingWindow = function(nums, k) {
  if (nums.length === 0) return nums;
  const r = [];
  for (let i = k; i <= nums.length; i++) {
    r.push(Math.max(...nums.slice(i - k, i)));
  }
  return r;
};
我当时还特别疑惑为什么此题的难度为hard。

编程语言有时候会限制个人的思维， 前端的代码没有遇到过复杂的数据结构， 导致一些思路根本打不开，这也是我需要克服的一点。

老师的思路我懂了后，仍然无法下笔。因为我感觉好多case要考虑。

然后看了一下大家的评论也没有我想得到的。我最困惑的的是这么复杂的过程，怎么实现？

1.思路:what
使用一个容器(容量k)保存最大的，以及最大后面的。最大之前的值，在之后寻找最大值过程中都用不上。
按理说只需要保存一个最大值。但是最大之后的小值也需要保存，作用是之后用来判断容器是否满了(达到k个)。

2.实现:how
这里面到底要考虑几种case啊？答案是两种。
以最大值进来时是否在最左边为依据来实现代码。

一种，最大值在k个的最左边，这样下一次进来一个值之前需要先删除最左边的。

另一种，最大值不在最左边，有足够的空间给下次进来。此时需要删除最大值左边的，让最大值始终在最左边。

3.为什么这个是o(n)?为啥要双端？why

整个思路过程中的运算时间复杂度都在2里面删除操作和进入操作和比较操作。
自己模拟一下，会发现所有的删除操作加起来为o(n)。
进入操作就是一次遍历o(n)。
比较操作也是一次遍历o(n)。


为啥要双端？
对于3,-1,1的情况，如果进来一个2，那就需要从右边出来了。

新元素进入window要从右侧元素开始比较，不能从左侧比较。
 var maxSlidingWindow = function (nums, k) {
      const window = [];
      const result = [];
      for (let i = 0; i < nums.length; i++) {
        if (i - window[0] > k - 1) {
          window.shift();
        }
        let j = window.length - 1;
        while (j >= 0 && nums[window[j]] <= nums[i]) {
          j--;
          window.pop();
        }
        window.push(i);
        if (i >= k - 1) {
          result.push(nums[window[0]]);
        }
      }
      return result;
    };

Java 版实现Heap解法：

```Java
  int[] maxSlidingWindowHeap(int[] nums, int k) {
    if (nums == null || nums.length == 0 || k < 0 || k > nums.length) return nums;

    int[] result = new int[nums.length - k + 1];
    PriorityQueue<Integer> priorityQueue =
        new PriorityQueue<>(k, Collections.<Integer>reverseOrder());

    for (int i = 0; i < k; i++) {
      priorityQueue.offer(nums[i]);
    }

    result[0] = priorityQueue.peek();

    for (int j = k; j < nums.length; j++) {
      priorityQueue.offer(nums[j]);
      priorityQueue.remove(nums[j - k]);
      result[j - k + 1] = Objects.requireNonNull(priorityQueue.peek());
    }

    return result;
  }
```

test case:
第一类 - Happy case：
1. nums = {1, 3, -1, -3, 5, 3, 6, 7}, k = 3
2. nums = {1, -1}, k =1
3. nums = {1, 3, -1, -3, 5, 3, 6, 7}, k = 8

第二类 - bad case:

4. nums = null, k = 0
5. nums = {}, k = 0
6. nums = {1}, k = -1
7. nums = {1}, k = 2