看到这道题我就有印象， 我在剑指offer里面做过这道题，我记得当时用的是优先队列，然后我脑子里一下子就有了想法，拿优先队列作为窗口，每往右移动一步，把左边的数remove掉，把右边的数add进来，然后把队头，也就是窗口中最大的元素放入答案数组，然后就写出了如下代码：

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
       int n = nums.length;
       int[] ans = new int [n-k+1];
       int index =0;
       PriorityQueue<Integer> queue = new PriorityQueue<>(new Comparator<>(){
           public int compare(Integer o1, Integer o2){
               return o2-o1;
           }
       });
       for(int i=0;i<k;i++){
           queue.add(nums[i]);
       }
       ans[index++] = queue.peek();
       for(int i=k;i<n;i++){
           queue.remove(nums[i-k]);
           queue.add(nums[i]);
           ans[index++] = queue.peek();
       }
       return ans;
    }
}

我是没想到我用一遍for循环都能超时，然后我就想了下觉得没问题啊，我之前是这样做的啊。然后看了一下自己之前写的题解:

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
       int n = nums.length;
       int[] ans = new int [n-k+1];
       int index =0;
       PriorityQueue<int[]> queue = new PriorityQueue<>(new Comparator<int[]>(){
           public int compare(int[] o1, int[] o2){
               return o2[0]!=o1[0] ? o2[0]-o1[0] : o2[1]-o1[1];
           }
       });
       for(int i=0;i<k;i++){
           queue.add(new int[]{nums[i], i});
       }
       ans[index++] = queue.peek()[0];
       for(int i=k;i<n;i++){
           queue.add(new int[]{nums[i], i});
           while(queue.peek()[1] <= i-k){
               queue.poll();
           }
           ans[index++] = queue.peek()[0];
       }
       return ans;
    }
}

队列里面存的不是数组的元素，而是一个大小为2的数组(其实有点像k-v键值对)，数组第0个元素是参数数组nums中的值，第1个元素是这个值在nums中的下标，这样的话他就少了remove的一步，我是add一个就remove一个，这个是通过下标判断，如果队头这个最大的元素的下标在窗口的左边就直接poll，否则不用管，这样既少了每次remove而且poll的效率比remove还高，所以这个算法效率就更高了。