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

239. 滑动窗口最大值

题目链接：https://leetcode.cn/problems/sliding-window-maximum/
文档讲解：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
视频讲解：https://www.bilibili.com/video/BV1XS4y1p7qj

思路

• 需要使用Deque来自己构造一个单调队列。
• 当单调队列push时，如果队列里的值小于要加入的值，就将前面的值弹出，保证队列中的数是单调递减的。
• 当单调队列pop时，需要保证弹出的值与本该弹出的值相等，否则可能之前就被弹出了，这次就不操作。
• 最后，每次获得最大值，其实都是在获取队头的值。

代码

class Solution {
    public class MyQueue {
        Deque<Integer> deque = new LinkedList<>();
        public int getMaxValue() {
            return deque.peek();
        }

        public void push(int val) {
            while (!deque.isEmpty() && val > deque.getLast()) deque.removeLast();
            deque.add(val);
        }

        public void pop(int val) {
            if (!deque.isEmpty() && val == deque.peek()) deque.poll();
        }
    }

    public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums.length == 1) return nums;
        MyQueue myQueue = new MyQueue();
        int[] res = new int[nums.length - k + 1];
        int num = 0;
        for (int i = 0; i < k; i++) {
            myQueue.push(nums[i]);
        }
        res[num++] = myQueue.getMaxValue();
        for (int i = k; i < nums.length; i++) {
            myQueue.pop(nums[i - k]);
            myQueue.push(nums[i]);
            res[num++] = myQueue.getMaxValue();
        }
        return res;
    }
}

分析：时间复杂度：O(n)，空间复杂度：O(k)，自己定义了最大长度为k的辅助单调队列。

#347.前 K 个高频元素

题目链接：https://leetcode.cn/problems/top-k-frequent-elements/
文档讲解：https://programmercarl.com/0347.%E5%89%8DK%E4%B8%AA%E9%AB%98%E9%A2%91%E5%85%83%E7%B4%A0.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
视频讲解：https://www.bilibili.com/video/BV1Xg41167Lz

思路

• 定义一个PriorityQueue的大顶堆，先用Map统计元素出现个数，然后放入大顶堆中，大顶堆中先输出大的数，所以直接输出前k个数。
• 注意大顶堆的定义方法PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2) -> pair2[1] - pair1[1])。

代码

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
        }
        PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2) -> pair2[1] - pair1[1]);
        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
            pq.add(new int[]{entry.getKey(), entry.getValue()});
        }
        int[] res = new int[k];
        for (int i = 0; i < k; i++) res[i] = pq.poll()[0];

        return res;
    }
}

分析：时间复杂度：O(nlogn)，空间复杂度：O(n)。

时间复杂度分析

1. 构建频率表：

   for (int i = 0; i < nums.length; i++) {
       map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
   }
   

   这部分代码使用一个for循环遍历数组nums，构建一个哈希表map，记录每个数字出现的频率。这个步骤的时间复杂度是O(n)，其中n是数组nums的长度。

2. 构建优先队列：

   PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2) -> pair2[1] - pair1[1]);
   for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
       pq.add(new int[]{entry.getKey(), entry.getValue()});
   }
   

   这部分代码遍历频率表，将所有元素及其频率插入优先队列pq。由于map最多包含n个不同的元素，因此这个步骤的时间复杂度是O(m log m)，其中m是哈希表map的大小，最多为n。

3. 获取前k个频繁元素：

   int[] res = new int[k];
   for (int i = 0; i < k; i++) res[i] = pq.poll()[0];
   

   这部分代码从优先队列中提取前k个元素，每次提取操作的时间复杂度是O(log m)，所以总的时间复杂度是O(k log m)。

综合起来，整体时间复杂度为：O(n) + O(m \log m) + O(k \log m)
由于m最大为n，可以简化为：O(n) + O(n \log n) + O(k \log n)
在最坏情况下，时间复杂度为：O(n \log n)

空间复杂度分析

1. 哈希表的空间：

   Map<Integer, Integer> map = new HashMap<>();
   

   哈希表map存储每个数字及其频率，最多存储n个元素，因此其空间复杂度为O(n)。

2. 优先队列的空间：

   PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2) -> pair2[1] - pair1[1]);
   

   优先队列pq存储最多n个元素（每个元素是一个大小为2的数组），其空间复杂度为O(n)。

3. 结果数组的空间：

   int[] res = new int[k];
   

   结果数组res存储k个元素，其空间复杂度为O(k)。

综合起来，整体空间复杂度为：O(n) + O(n) + O(k)
在最坏情况下，空间复杂度为：O(n)