代码随想录算法训练营day10|150. 逆波兰表达式求值、239. 滑动窗口最大值、347.前 K 个高频元素

1. 逆波兰表达式求值

题目链接：https://leetcode.cn/problems/evaluate-reverse-polish-notation/
题目解析：https://programmercarl.com/0150.%E9%80%86%E6%B3%A2%E5%85%B0%E8%A1%A8%E8%BE%BE%E5%BC%8F%E6%B1%82%E5%80%BC.html

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();
        for (String s : tokens) {
            if ("+".equals(s)) {
                stack.push(stack.pop() + stack.pop());
            } else if ("-".equals(s)) {
                stack.push(-stack.pop() + stack.pop());
            } else if ("*".equals(s)) {
                stack.push(stack.pop() * stack.pop());
            } else if ("/".equals(s)) {
                int right = stack.pop();
                stack.push(stack.pop() / right);
            } else {
                stack.push(Integer.valueOf(s));
            }
        }
        return stack.pop();
    }
}

Integer.valueOf(s) 会尝试把这个字符串解析成对应的整数值，并返回一个表示该整数值的 Integer 对象。

2. 滑动窗口最大值

题目链接：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

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums.length == 0 || k == 0) return new int[0];
        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++) {
            // 删除 deque 中对应的 nums[i-1]
            if(i > 0 && deque.peekFirst() == nums[i - 1])
                deque.removeFirst();
            // 保持 deque 递减
            while(!deque.isEmpty() && deque.peekLast() < nums[j])
                deque.removeLast();
            deque.addLast(nums[j]);
            // 记录窗口最大值
            if(i >= 0)
                res[i] = deque.peekFirst();
        }
        return res;
    }
}

3. 前 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

class Solution {
    //解法2：基于小顶堆实现
    public int[] topKFrequent2(int[] nums, int k) {
        // 第一步：统计每个元素的出现次数
        // 创建一个 HashMap 用于存储数组元素及其出现的次数
        // key 为数组元素值，val 为对应出现次数
        Map<Integer,Integer> map = new HashMap<>(); 
        // 遍历数组 nums 中的每个元素
        for (int num : nums) {
            // 使用 getOrDefault 方法获取当前元素 num 在 map 中的出现次数
            // 如果 num 不在 map 中，getOrDefault 返回默认值 0，然后加 1
            // 如果 num 已经在 map 中，获取其当前出现次数并加 1
            map.put(num, map.getOrDefault(num, 0) + 1);
        }

        // 第二步：使用优先队列（小顶堆）来维护出现次数前 k 多的元素
        // 在优先队列中存储二元组 (num, cnt)，cnt 表示元素值 num 在数组中的出现次数
        // 出现次数按从队头到队尾的顺序是从小到大排，出现次数最低的在队头（相当于小顶堆）
        // PriorityQueue 的比较器 (pair1, pair2) -> pair1[1] - pair2[1] 用于定义元素的排序规则
        // pair1 和 pair2 是数组，pair1[1] 和 pair2[1] 分别是它们代表元素的出现次数
        // 若 pair1[1] - pair2[1] < 0，则 pair1 排在 pair2 前面，实现小顶堆
        PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2) -> pair1[1] - pair2[1]);
        // 遍历 map 中的每个键值对
        for (Map.Entry<Integer, Integer> entry : map.entrySet()) { 
            // 小顶堆只需要维持 k 个元素有序
            if (pq.size() < k) { 
                // 当小顶堆元素个数小于 k 个时，直接将当前元素及其出现次数添加到小顶堆中
                // 以数组 {元素值, 出现次数} 的形式添加
                pq.add(new int[]{entry.getKey(), entry.getValue()});
            } else {
                // 当前元素的出现次数大于小顶堆的根结点（这 k 个元素中出现次数最少的那个）
                if (entry.getValue() > pq.peek()[1]) { 
                    // 弹出队头（小顶堆的根结点），即把堆里出现次数最少的那个删除
                    pq.poll(); 
                    // 将当前元素及其出现次数添加到小顶堆中
                    pq.add(new int[]{entry.getKey(), entry.getValue()});
                }
            }
        }

        // 第三步：将小顶堆中的元素按出现次数从多到少的顺序存入结果数组
        int[] ans = new int[k];
        // 依次弹出小顶堆，先弹出的是堆的根，出现次数少，后面弹出的出现次数多
        for (int i = k - 1; i >= 0; i--) { 
            // 弹出小顶堆的元素，取其元素值（数组的第一个元素）存入结果数组
            ans[i] = pq.poll()[0];
        }
        // 返回结果数组
        return ans;
    }
}