代码随想录算法训练营第十三天| LeetCode239 滑动窗口最大值 、LeetCode347 前 K 个高频元素

LeetCode239 滑动窗口最大值

题目链接：https://programmercarl.com/0239.%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3%E6%9C%80%E5%A4%A7%E5%80%BC.html代码：

class MyQueue {
    Deque<Integer> deque = new LinkedList<>();
    // 当滑动窗口要丢弃的元素等于当前队列出口处的元素时，做pop操作
    void poll(int val) {
        if (!deque.isEmpty() && val == deque.peek()) {
            deque.poll();
        }
    }
    // 滑动窗口要加入队列的元素要和队尾元素作比较，如果大于队尾元素，要把队尾元素舍弃，直到新加入的元素小于队尾元素
    void add(int val) {
        while (!deque.isEmpty() && val > deque.peekLast()) {
            deque.pollLast();
        }
        deque.add(val);
    }
    // 返回队头元素，此时队头元素维护的就是当前滑动窗口的最大值
    int getMax() {
        return deque.peek();
    }

}

public class code239 {
    public int[] maxSlidingWindow(int[] nums, int k) {
        // 定义存放结果的数组
        int[] res = new int[nums.length - k + 1];
        int n = 0;
        MyQueue myQueue = new MyQueue();

        // 先把前k个元素加入到队列中
        for (int i = 0; i < k; i++) {
            myQueue.add(nums[i]);
        }
        res[n++] = myQueue.getMax();
        for (int i = k; i < nums.length; i++) {

            // 滑动窗口移动伴随着队列的pop和push
            myQueue.poll(nums[i - k]);
            myQueue.add(nums[i]);
            // 每次滑动窗口移动后要将队列中维护的最大值加入到结果数组当中
            res[n++] = myQueue.getMax();
        }
        return res;
    }
}

大体思路就是维护一个单调队列，滑动窗口新加入的元素如果大于队尾元素，则移除队尾元素，这样每次滑动窗口移动完之后，队头元素就是该滑动窗口中的最大值

LeetCode347 前 K 个高频元素

题目链接：https://programmercarl.com/0347.%E5%89%8DK%E4%B8%AA%E9%AB%98%E9%A2%91%E5%85%83%E7%B4%A0.html代码：

public class code347 {
    public int[] topKFrequent(int[] nums, int k) {

        // 维护一个哈希表，哈希表的键存放nums中的元素，对应的值存放该元素出现的频率
        Map<Integer, Integer> map = new HashMap<>();

        for (int num : nums) {
            map.put(num, map.getOrDefault(num, 0) + 1);
        }
        // 使用小顶堆进行排序，用优先级队列模拟小顶堆，优先级队列中只存储k个元素
        PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return map.get(o1) - map.get(o2);
            }
        });
        for (Integer key : map.keySet()) {
            if (pq.size() < k) {
                pq.add(key);
            } else if (map.get(key) > map.get(pq.peek())) {  // 当前元素出现次数大于栈顶元素出现次数
                pq.poll();
                pq.add(key);
            }

        }
        int[] res = new int[k];
        for (int i = k - 1; i >= 0 ; i--) {
            res[i] = pq.poll();
        }
        return res;
        
    }
}

使用优先级队列模拟小顶堆，具体实现看代码，代码写了注释