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

150.逆波兰表达式求值

题目链接：150. 逆波兰表达式求值 - 力扣（LeetCode）

栈的经典应用，没什么难点，但有个坑，leetcode上没办法用“==”来判断字符串之间的相等，只能用equals。

class Solution {
    public static int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();
        for (int i = 0; i < tokens.length; i++) {
            if ("+".equals(tokens[i])) {
                int a = stack.pop();
                int b = stack.pop();
                stack.push(a + b);
            } else if ("-".equals(tokens[i])) {
                int a = stack.pop();
                int b = stack.pop();
                stack.push(b - a);
            } else if ("*".equals(tokens[i])) {
                int a = stack.pop();
                int b = stack.pop();
                stack.push(a * b);
            } else if ("/".equals(tokens[i])) {
                int a = stack.pop();
                int b = stack.pop();
                stack.push(b / a);
            } else {
                stack.push(Integer.parseInt(tokens[i]));
            }
        }
        return stack.pop();
    }
}

239.滑动窗口最大值

题目链接：239. 滑动窗口最大值 - 力扣（LeetCode）

复杂点就是两层for循环，外层用来移动窗口，内层用来寻找最大值。时间复杂度是n*k

因为窗口移动的过程很像队列的入队和出队操作，所以用队列来做。

代码随想录：

在题解中有一个我认为很妙的想法：如果能有一个class，类中包含了三个方法，一个pop，一个push，还有一个getMaxValue，在窗口滑动时，pop出队首元素，push进队尾元素，然后getMaxValue就能获得当前窗口中的最大值，那么这道题很容易就能解决。这样就将问题简化成了：如何实现一个方法，能够获取当前窗口下的最大值。这种思考方法类似的还有自己构建一个class，其中的属性值和方法都是自己需要的。之前做华为笔试的时候，这种自己定义一个类的方法就解决了第二题。

为什么不能用优先级队列（大顶堆）？在pop出元素的时候，不知道该pop优先级队列中的哪个元素，因为队列口始终是最大值，不能直接pop。

引入单调队列的概念：队列中只维护有可能成为最大值的元素，不用维护窗口中的所有元素。

pop( )的实现：如果需要pop的元素等于队列出口处的元素，就pop，否则跳过。

push( )的实现：当push进来一个元素后，要将队列中该元素前所有小于自己的元素都pop出去，队列出口只留下自己。

getMaxValue( )：直接弹出队列出口处的元素即可。

为什么要用双端队列Deque而不用Queue，关键就在于，使用双端队列可以实现将队列中该元素前所有小于自己的元素都pop出去，因为Deque有个方法getLast（）。

class MyQueue {
    Deque<Integer> queue;

    public MyQueue() {
        queue = new LinkedList<>();
    }

    public void pop(int num) {
        if (!queue.isEmpty() && num == queue.peek()) {
            queue.poll();
        }
    }

    public void push(int num) {
        while (!queue.isEmpty() && queue.getLast() < num) {
            queue.removeLast();

        }
        queue.add(num);
    }

    public int getMaxValue() {
        return queue.peek();
    }
}

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        MyQueue myQueue = new MyQueue();
        int[] result = new int[nums.length - k + 1];
        for (int i = 0; i < k; i++) {
            myQueue.push(nums[i]);
        }
        result[0] = myQueue.getMaxValue();
        for (int i = 0, j = k; j < nums.length; i++, j++) {
            myQueue.push(nums[j]);
            myQueue.pop(nums[i]);
            result[i + 1] = myQueue.getMaxValue();
        }
        return result;
    }
}

347. 前K个高频元素

题目链接：347. 前 K 个高频元素 - 力扣（LeetCode）

看题只能想到用哈希表记录元素出现的次数，然后输出次数排在前k个的元素，那么这道题的难点就在于对map中存储的键值对，按照value的大小从大到小进行排序。但由于这里只要求前k个元素，因此只要维护含有k个元素的有序数据结构就可以。

代码随想录：

引入了大顶堆（小顶堆）即优先级队列

应该使用大顶堆还是小顶堆？由于大顶堆的队首是最大的元素，因此当pop一个元素的时候，将大的值给pop出去了，那么最后剩下的反而是k个最小的值，因此要使用小顶堆。

由于堆是一个二叉树的数据结构，而且只维护k个元素，因此时间复杂度是logk

这道题在编写代码的过程中用到了很多优先级队列的操作，包括定义小顶堆的时候用到的语句，值得反复练习。

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        Map<Integer,Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            if (map.containsKey(nums[i])) {
                Integer value = map.get(nums[i]);
                value++;
                map.put(nums[i], value);
            } else {
                map.put(nums[i], 1);
            }
        }

        PriorityQueue<int[]> pq = new PriorityQueue<>((o1, o2) -> o1[1] - o2[1]);
        int[] res = new int[k];
        for (Map.Entry<Integer, Integer> x : map.entrySet()) {
            int[] tmp = new int[2];
            tmp[0] = x.getKey();
            tmp[1] = x.getValue();
            pq.offer(tmp);
            if (pq.size() > k) {
                pq.poll();
            }
        }
        for (int i = 0; i < k; i++) {
            res[i] = pq.poll()[0];
        }
        return res;

    }
}

day11完结撒花~