代码随想录Day 13

239. 滑动窗口最大值

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。
返回 滑动窗口中的最大值 。
示例 1：
输入：nums = [1,3,-1,-3,5,3,6,7], k = 3
输出：[3,3,5,5,6,7]

这个题刚开始做并没有思路，只能想到暴力解决的一个方法。暴力方法，遍历一遍的过程中每次从窗口中再找到最大的数值，是O(n × k)的算法。本题是单调队列的经典应用。

核心思路：队列没有必要维护窗口里的所有元素，只需要维护有可能成为窗口里最大值的元素就可以了，同时保证队列里的元素数值是由大到小的

设计单调队列的时候，pop，和push操作要保持如下规则：

poll(value)：如果窗口移除的元素value等于单调队列的出口元素，那么队列弹出元素，否则不用任何操作；

offer(value)：如果offer的元素value大于入口元素的数值，那么就将队列入口的元素弹出，直到push元素的数值小于等于队列入口元素的数值为止；

保持如上规则，每次窗口移动的时候，只要问deque.peek()就可以返回当前窗口的最大值。
使用单调队列的时间复杂度是 O(n)。

完整代码如下：

class MyQueue{
    Deque<Integer> deque = new LinkedList<>();
    public void poll(int val){
        //当队列的出口元素与要poll的元素相等时，进行poll操作
        if(!deque.isEmpty() && deque.peekFirst() == val){
            deque.pollFirst();
        }
    }

    public void offer(int val){
        //添加元素，删除队列中所有比加入元素小的元素
        while(!deque.isEmpty() && deque.peekLast() < val){
            deque.removeLast();
        }
        deque.offerLast(val);
    }

    public int peek(){
        return deque.peekFirst();
    }

}


class Solution {

    public int[] maxSlidingWindow(int[] nums, int k) {
         if(nums.length == 1){
            return nums;
        }

        int[] res = new int[nums.length - k + 1];
        int resPos = 0;

        MyQueue myQueue = new MyQueue();
        for(int i = 0; i < k; i++){
            myQueue.offer(nums[i]);
        }
        res[resPos++] = myQueue.peek();

        for(int i = k ;i < nums.length; i++){
            myQueue.offer(nums[i]);
            myQueue.poll(nums[i - k]);
            res[resPos++] = myQueue.peek();
        }

        return res;
    }
}

347. 前 K 个高频元素

给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。
示例 1:
输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]

本题返回其中出现频率前 k 高的元素，那么首先要把元素的实现频率统计一下，就立刻想到使用Map。其次，通过最大堆/最小堆来返回出现频率前K高的元素。

推荐使用小顶堆，我们维护k个有序的序列，因为要统计最大前k个元素，只有小顶堆每次将最小的元素弹出，最后小顶堆里积累的才是前k个最大元素。

完整代码如下：

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
         Map<Integer,Integer> map = new HashMap<>();
        //统计每个元素出现频率
        for (int num : nums){
            map.put(num, map.getOrDefault(num,0) + 1);
        }

        出现次数按从队头到队尾的顺序是从小到大排,出现次数最低的在队头(相当于小顶堆)
        //可以简写为
        //PriorityQueue<int[]> pq = new PriorityQueue<>((o1, o2)->o1[1]-o2[1]);
        PriorityQueue<int[]> pq = new PriorityQueue<>(new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o1[1] - o2[1];
            }
        });

        for(Map.Entry<Integer, Integer> entry : map.entrySet()){
            if(pq.size() < k){
                pq.add(new int[]{entry.getKey(), entry.getValue()});
            }else{
                if(entry.getValue() > pq.peek()[1]){
                    pq.poll();
                    pq.add(new int[]{entry.getKey(), entry.getValue()});
                }
            }
        }

        int res[] = new int[k];
        for (int i = k - 1; i >= 0 ; i--) {
        	//依次弹出小顶堆,先弹出的是堆的根,出现次数少,后面弹出的出现次数多
            res[i] = pq.poll()[0];

        }
        return res;

    }
}

map.getOrDefault(Object key, V defaultValue)：
如果 在Map中存在key，则返回key所对应的的value。
如果 在Map中不存在key，则返回默认值。

Java 优先级队列

PriorityQueue，即优先级队列。PriorityQueue是Queen接口的一个实现类。优先级队列可以保证每次取出来的元素都是队列中的最小或最大的元素（Java优先级队列默认每次取出来的为最小元素

可以通过comparator比较器来自定义每次获取为最小还是最大。

JDK1.8中的PriorityQueue底层使用了堆的数据结构，而堆实际就是在完全二叉树的基础上进行了一些元素的调整