Day11 | 150. 逆波兰表达式求值 | 347. 前 K 个高频元素 | 239. 滑动窗口最大值

150. 逆波兰表达式求值 - 力扣（LeetCode）

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack();
        for (int i = 0; i < tokens.length; i++) {
            char t = tokens[i].toCharArray()[0];
            if (Character.isDigit(t) || (t == '-' && tokens[i].length() > 1)) {
                stack.push(Integer.valueOf(tokens[i]));
            } else {
                int a = stack.pop();
                int b = stack.pop();
                switch (t) {
                    case '+':
                        stack.push(a + b);
                        break;
                    case '-':
                        stack.push(b - a);
                        break;
                    case '*':
                        stack.push(a * b);
                        break;
                    case '/':
                        stack.push(b / a);
                        break;
                }
            }
        }
        return stack.peek();
    }
}

理解逆波兰式表达式，栈的特性，先进后出，所以得注意别弄反操作数的前后关系。

347. 前 K 个高频元素 - 力扣（LeetCode）

import java.util.*;

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

        PriorityQueue<int[]> minHeap = new PriorityQueue<>((a, b) -> a[1] - b[1]);
        for (Map.Entry<Integer, Integer> entry : frequencyMap.entrySet()) {
            minHeap.offer(new int[] { entry.getKey(), entry.getValue() });
            if (minHeap.size() > k) {
                minHeap.poll();
            }
        }

        int[] result = new int[k];
        for (int i = k - 1; i >= 0; i--) {
            result[i] = minHeap.poll()[0];
        }

        return result;
    }
}

lambda表达式中，(a,b) -> menthod(a) - menthod(b);a在前就是降序，b在前就是升序。

239. 滑动窗口最大值 - 力扣（LeetCode）

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        Deque<Integer> deque = new LinkedList<>();
        int[] result = new int[nums.length-k+1];
        int n = 0;
        for(int i = 0;i<nums.length;i++){
            //删除队列头部小于当前元素的元素
            while(!deque.isEmpty() && nums[i]>deque.peekLast()){
                deque.removeLast();
            }
            deque.add(nums[i]);

            //如果队列头部元素不在当前窗口内，就删除它
            if(i >= k){
                deque.removeFirst();
            }
            //将当前窗口的最大值存入结果数组
            if(i>=k-1 && deque.peekFirst()!= null){
                result[n++] = deque.peekFirst();
            }
            
        }
        return result;
    }
}

这是一个错误版本，这题做不来。