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

一、150. 逆波兰表达式求值

题目链接：https://leetcode.cn/problems/evaluate-reverse-polish-notation/description/
文章讲解：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
视频讲解：https://www.bilibili.com/video/BV1kd4y1o7on

1.1 初见思路

1. 就是用栈，碰到符号，就弹出最上面的2个元素，计算完后吧结果再push进栈

1.2 具体实现

class Solution {
    public int evalRPN(String[] tokens) {
       Deque<Integer> deque = new LinkedList();
        for (int i = 0; i < tokens.length; i++) {
            String token = tokens[i];
            if(token.equals("+")){
                int num2 = deque.pop();
                int num1 = deque.pop();
                deque.push(num1+num2);
            }
            else if(token.equals("-")){
                int num2 = deque.pop();
                int num1 = deque.pop();
                deque.push(num1-num2);
            }
            else if(token.equals("*")){
                int num2 = deque.pop();
                int num1 = deque.pop();
                deque.push(num1*num2);
            }
            else if(token.equals("/")){
                int num2 = deque.pop();
                int num1 = deque.pop();
                deque.push((num1/num2));
            }
            else{
                deque.push(Integer.parseInt(token));
            }
        }
        return deque.pop();
    }
}

1.3 重难点

二、 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

2.1 初见思路

1. 使用双端队列，得知道移动时，应该去除哪个值，增加哪个值
2. 记录当前窗口内最大值，若移除了最大值，则重新比一遍窗口内的最大值
3. 若未移除最大值，比较新增值和最大值，更新最大值

2.2 具体实现

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        int[] res = new int[nums.length-k+1];
        int maxNum=Integer.MIN_VALUE;
        LinkedList<Integer> linkedList = new LinkedList<>();
        for(int i=0;i<k;i++){
            linkedList.addLast(nums[i]);
            maxNum=Math.max(nums[i],maxNum);
        }
        res[0]=maxNum;
        for(int i=k;i<nums.length;i++){
           
            
            int outNum = linkedList.peekFirst();
            //若未移除最大值，比较新增值和最大值
            if(outNum!=maxNum){
                maxNum=maxNum<nums[i]?nums[i]:maxNum;
                linkedList.pollFirst();
                linkedList.addLast(nums[i]);
            }
            else{
                linkedList.pollFirst();
                linkedList.addLast(nums[i]);
                //重新比一遍窗口内的最大值
                maxNum = getMax(linkedList);
            }
            
             res[i-k+1]=maxNum;
        }
        return res;
    }

    public int getMax(LinkedList<Integer> list){
        int max=Integer.MIN_VALUE;
        for (Integer integer : list) {
            max=Math.max(max,integer);
        }
        return max;
    }
}
上面的实现方式会在k很大的时候超时，因为getMax()方法会遍历，所以会超时；
得使用双端队列构建出有序队列
class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        ArrayDeque<Integer> deque = new ArrayDeque<>();
        int n = nums.length;
        int[] res = new int[n - k + 1];
        int idx = 0;
        for(int i = 0; i < n; i++) {
            // 根据题意，i为nums下标，是要在[i - k + 1, i] 中选到最大值，只需要保证两点
            // 1.队列头结点需要在[i - k + 1, i]范围内，不符合则要弹出
            while(!deque.isEmpty() && deque.peek() < i - k + 1){
                deque.poll();
            }
            // 2.既然是单调，就要保证每次放进去的数字要比末尾的都大，否则也弹出
            while(!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
                deque.pollLast();
            }

            deque.offer(i);

            // 因为单调，当i增长到符合第一个k范围的时候，每滑动一步都将队列头节点放入结果就行了
            if(i >= k - 1){
                res[idx++] = nums[deque.peek()];
            }
        }
        return res;
    }
}

2.3 重难点

• 要会使用双端队列构建出有序队列

三、 347. 前 K 个高频元素

题目链接：https://leetcode.cn/problems/top-k-frequent-elements/description/
文章讲解：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

3.1 初见思路

3.2 具体实现

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

        PriorityQueue<Integer> queue = new PriorityQueue<>((p1,p2)->{
            return map.get(p1)-map.get(p2);
        });
        for(Map.Entry<Integer,Integer> entry:map.entrySet()){
            //queue不满的时候直接插入
            if(queue.size()<k){
                queue.add(entry.getKey());
            }
            //queue满了就需要移除后再插入
            else if(entry.getValue()>map.get(queue.peek())){
                queue.remove();
                queue.add(entry.getKey());
            }
        }
        int[] res = new int[queue.size()];
        int index=0;
        for(int i=k-1;i>=0;i--){//依次弹出小顶堆,先弹出的是堆的根,出现次数少,后面弹出的出现次数多
            res[i] = queue.poll();
        }
        return res;
    }
}