LeetCode Day13|● 150. 逆波兰表达式求值(后缀表达式适合计算机运算)● 239. 滑动窗口最大值(自己实现单调队列)● 347.前 K 个高频元素（key:元素value:次数）

day42-1 ● 150. 逆波兰表达式求值

什么是逆波兰表达式

后缀表达式是一种很适合计算机来做运算的一种表达式，因为后续表达式不需要加括号

如何使用栈来计算

栈的计算过程： 遇见数字就加入到栈里面 ，遇见操作符就从栈里面取出元素做计算然后再把数字加入到栈中
括号匹配也是用栈来解决的
消除字符串中的重复项

代码实现

class Solution {
    public int evalRPN(String[] tokens) {
        Deque<Integer> stack = new LinkedList<>();
        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 a = stack.pop();
                int b = stack.pop();
                stack.push(b / a);
            }else {
                stack.push(Integer.valueOf(s));
            }
        }
        return stack.pop();
    }
}

总结

关键是理解逆波兰表达式

day42-2 ● 239. 滑动窗口最大值 （有点难度，可能代码写不出来，但一刷至少需要理解思路）

整体思路

难点：如何求窗口里面的最大值
一pop一push
优先级队列：大顶堆或者小顶堆，只不过是单调递增或单调递减，大顶堆最大元素在最上面，小顶堆最小元素在最下面
使用优先级队列顺序会改变，所有不能使用优先级队列，所有得自己实现队列，这种队列叫单调队列

单调队列模拟过程

代码实现

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if (nums.length == 1) {
            return nums;
        }
        int len = nums.length - k + 1;
        // 存放结果元素
        int[] res = new int[len];
        int num = 0;
        // 自定义队列
        MyQueue myQueue = new MyQueue();
        // 先将前k的元素放入队列
        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<Integer> deque = new LinkedList<>();
    // 弹出元素时，比较当前要弹出的数值是否等于队列出口的数值，如果相等则弹出
    void poll(int val){
        if(!deque.isEmpty() && deque.peek() == val){
            deque.poll();
        }
    }
    // 添加元素时，如果要添加的元素大于入口处的元素，就将入口元素弹出，保证队列元素单调递减
    // 比如此时队列元素3,1，2将要入队，比1大，所以1弹出，此时队列：3,2
    void  add(int val){
        while (!deque.isEmpty() && deque.peekLast() < val){
            deque.removeLast();
        }
        deque.add(val);
    }
    // 队列队顶元素始终为最大值
    int peek(){
        return deque.peek();
    }

}

总结

day42-3 ● 347.前 K 个高频元素 （有点难度，可能代码写不出来，一刷至少需要理解思路

整体思路

用小顶堆，每次pop最小的元素，留下的都是最大的

代码实现

class Solution {
    // 最小堆实现
    public int[] topKFrequent(int[] nums, int k) {
        // key为数组元素 val为对应的出现次数
        Map<Integer, Integer> map = new HashMap<>();
        for (int num : nums) {
            map.put(num, map.getOrDefault(num, 0) + 1);
        }
        PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2) -> pair1[1] - pair2[1]);
        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
            // 最小顶堆元素个数小于k个时直接加
            if (pq.size() < 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[] res = new int[k];
        // 依次弹出小顶堆,先弹出的是堆的根,出现次数少,后面弹出的出现次数多
        for (int i = k - 1; i >= 0; i--) {
            res[i] = pq.poll()[0];
        }
        return res;
    }
}

总结

如何统计频率
如何用堆来解决前K个高频的问题

day42-4 ● 总结