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

 239. 滑动窗口最大值 （一刷至少需要理解思路）

题目链接/文章讲解/视频讲解：代码随想录

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

        int[] res = new int[nums.length - k + 1];
        int num = 0;
        MyQueue myQueue = new MyQueue();

        for (int i = 0; i < k; i++) {
            myQueue.add(nums[i]);
        }

        res[num++] = myQueue.peek();

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

class MyQueue {
    Deque que = new LinkedList<>();
    void poll(int val) {
        if(!que.isEmpty() && val == que.peek()) {
            que.poll();
        }
    }

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

    int peek() {
        return que.peek();
    }
}

让我们通过模拟代码的执行流程来理解这个例子。给定的输入是 nums = [1,3,-1,-3,5,3,6,7] 和 k = 3。

我们将使用 MyQueue 来维护一个单调递减的队列，并用 res 数组来存储每个窗口的最大值。

初始状态

• nums = [1,3,-1,-3,5,3,6,7]
• k = 3
• res 数组的长度将是 nums.length - k + 1 = 8 - 3 + 1 = 6
• res = [0, 0, 0, 0, 0, 0]（初始填充为0）
• MyQueue 初始为空

滑动窗口模拟

1. 首次填充窗口:

   • 窗口为 [1, 3, -1]。
   • MyQueue 中加入 1，然后加入 3 时，1 被移除，因为 3 更大。接着尝试加入 -1，但 3 仍然保留，因为它更大。
   • MyQueue = [3, -1]
   • res[0] = 3（队首元素）

2. 第二个窗口:

   • 窗口移动为 [3, -1, -3]。
   • 移除 1（不在队列中），加入 -3。
   • MyQueue = [3, -1, -3]（3 仍然是最大的）
   • res[1] = 3

3. 第三个窗口:

   • 窗口移动为 [-1, -3, 5]。
   • 移除 3（队首元素），加入 5（-1 和 -3 被移除，因为 5 更大）。
   • MyQueue = [5]
   • res[2] = 5

4. 第四个窗口:

   • 窗口移动为 [-3, 5, 3]。
   • 移除 -1（不在队列中），加入 3。
   • MyQueue = [5, 3]
   • res[3] = 5

5. 第五个窗口:

   • 窗口移动为 [5, 3, 6]。
   • 移除 -3（不在队列中），加入 6（3 被移除，因为 6 更大）。
   • MyQueue = [6]
   • res[4] = 6

6. 第六个窗口:

   • 窗口移动为 [3, 6, 7]。
   • 移除 5（队首元素），加入 7（6 被移除，因为 7 更大）。
   • MyQueue = [7]
   • res[5] = 7

 347.前 K 个高频元素  （一刷至少需要理解思路）

题目链接/文章讲解/视频讲解：代码随想录

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        int[] result = new int[k];
        Map map = new HashMap<>();
         for (int num : nums) {
            map.put(num, map.getOrDefault(num, 0) + 1);
        }

        ArrayList> list = new ArrayList(map.entrySet());
        Collections.sort(list, (a, b) -> {
            return b.getValue() - a.getValue();
        });

        for (int i = 0; i < k; i++) {
            result[i] = list.get(i).getKey();
        }

        return result;
    }
}