代码随想录day11：栈与队列part3，单调队列&&优先队列（堆）

day11：栈与队列part3，单调队列&优先队列

239.滑动窗口最大值

单调队列应用，滑动窗口一进一出的过程很像队列的处理过程

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        // 维持一个单调队列
        Deque<Integer> deque = new LinkedList<>();
        // 存输出结果的数组
        int[] res = new int[nums.length - k + 1];
        for (int j = 0, i = 1 - k; j < nums.length; i++, j++) {
            if (i > 0 && deque.peekFirst() == nums[i - 1]) deque.removeFirst();
            while (!deque.isEmpty() && nums[j] > deque.peekLast()) deque.removeLast();
            deque.addLast(nums[j]);
            if (i >= 0) res[i] = deque.peekFirst();
        }
        return res;
    }
}

347.前k个高频元素

为什么用小根堆：维持一个k个元素的小根堆，将时间复杂度从O（nlogn）降低到 O（nlogk），多于k个元素时加入元素把堆顶（频率最小的）元素删除，剩下维护的就是频率最大的k个元素了

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int n : nums) {
            map.put(n, map.getOrDefault(n, 0) + 1);
        }
        PriorityQueue<Integer> heap = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer a, Integer b) {
                return map.get(a) - map.get(b);
            }
        });
        for (Integer key : map.keySet()) {
            if (heap.size() < k) heap.add(key);
            else {
                if (map.get(key) > map.get(heap.peek())) {
                    heap.remove();
                    heap.add(key);
                }
            }
        }
        int[] ans = new int[k];
        int i = 0;
        while (!heap.isEmpty()) ans[i++] = heap.remove();
        return ans;
    }
}