数据结构刷题（十一）：150逆波兰表达式求值、239滑动窗口最大值、347前K个高频元素

1.逆波兰表达式求值

题目链接

思路：使用栈；遇到数字则入栈，遇到运算符则取出栈顶两个数字进行计算。

注意：除法运算和减法运算两个元素的先后顺序。

扩展：逆波兰表达式相当于是二叉树中的后序遍历。

解法：

public int evalRPN(String[] token){

    Deque<Integer> stack = new LinkedList<>();
    for (String s : token) {
// leetcode 内置jdk的问题，不能使用==判断字符串是否相等
        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 temp1 = stack.pop();
            int temp2 = stack.pop();
            stack.push(temp2 / temp1);
        }
        // 遇到数字入栈
        else
            stack.push(Integer.valueOf(s));

    }
    return stack.pop();
}

2.滑动窗口最大值

题目链接

思路：

1. 使用双端队列Deque，重新定义一个单调队列

2. 理解滑动窗口过程：先pop队列的出口元素，后push一个队列的入口元素，最后求max

注意：

1. pop(value)：如果窗口移除的元素value等于单调队列的出口元素，那么队列弹出元素，否则不用任何操作。

2. push(value)：如果push的元素value大于当前入口元素的数值，那么就将当前队列入口的元素弹出，直到push元素的数值小于等于队列入口元素的数值为止

解法：

class MyQueue {
    Deque<Integer> deque = new LinkedList<>();
    //弹出元素时，比较当前要弹出的数值是否等于队列出口的数值，如果相等则弹出
    //同时判断队列当前是否为空
    void poll(int val) {
        if (!deque.isEmpty() && val == deque.peek()) {
            deque.poll();
        }
    }
    //添加元素时，如果要添加的元素大于入口处的元素，就将入口元素弹出
    //保证队列元素单调递减
    //比如此时队列元素3,1，2将要入队，比1大，所以1弹出，此时队列：3,2
    void offer(int val) {
        while (!deque.isEmpty() && val > deque.getLast()) {
            deque.removeLast();
        }
        deque.offer(val);
    }
    //队列队顶元素始终为最大值
    int peek() {
        return deque.peek();
    }
}

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的元素放入队列  不需要进行poll操作
        for (int i = 0; i < k; i++) {
            myQueue.offer(nums[i]);
        }
        res[num++] = myQueue.peek();
        for (int i = k; i < nums.length; i++) {
            //滑动窗口移除最前面的元素，移除是判断该元素是否放入队列
            myQueue.poll(nums[i - k]);
            //滑动窗口加入最后面的元素
            myQueue.offer(nums[i]);
            //记录对应的最大值
            res[num++] = myQueue.peek();
        }
        return res;
    }
}

3.前K个高频元素

题目链接

思路：使用优先队列，它的出队顺序与元素的优先级相关，不是按照普通队列出队

注意：见代码，每句都有注释

class Solution {
    public static int[] topKFrequent(int[] nums, int k) {
        // 新建map，key装入nums数组里的值，value装入这些值出现的次数
        Map<Integer, Integer> map = new HashMap<>();
        for (int num : nums) {
        // 使用getOrDefault，表示map不存在这个key时默认为0但会+1；存在这个key时直接+1
            map.put(num, map.getOrDefault(num, 0) + 1);
        }

        // 新建优先队列，存储二元数组(num,cnt), 还是key装入值num，value装入出现次数cnt
        // pair2[1] - pair1[1]表示降序排列，相当于大顶堆，
        // 即出现次数按从多到少排，也就是从队头到队尾的顺序,出现次数最多的在队头，方便出队
        PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2) -> pair2[1] - pair1[1]);
        // map的for循环格式如下，这里add时还需要新建int[],方便pq去添加；
        // 如果nums = [1,1,1,2,2,3]， 这里只会循环3次也就是不同数字的类别次    
        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
            pq.add(new int[]{entry.getKey(), entry.getValue()});

        }
        int[] ans = new int[k];
        // PriorityQueue特别在于他的出队顺序与元素的优先级有关，
        // 对PriorityQueue调用poll()方法，返回的总是优先级最高的元素
        for (int i = 0; i < k; i++) {
            ans[i] = pq.poll()[0];
        }
        return ans;
    }
}