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

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

150.逆波兰表达式求值

给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。

请你计算该表达式。返回一个表示表达式值的整数。

注意：

有效的算符为 ‘+’、‘-’、‘*’ 和 ‘/’ 。
每个操作数（运算对象）都可以是一个整数或者另一个表达式。
两个整数之间的除法总是 向零截断 。
表达式中不含除零运算。
输入是一个根据逆波兰表示法表示的算术表达式。
答案及所有中间计算结果可以用 32 位 整数表示。

示例 1：

输入：tokens = [“2”,“1”,“+”,“3”,“*”]
输出：9
解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9

题解：遇到数字则将数字加入到栈中，遇到符号则依次弹出栈顶的两个元素进行运算。需要注意的是，字符串比较内容相等用equals。
代码：

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> s=new Stack<>();
        for(int i=0;i<tokens.length;i++){
            if(tokens[i].equals("+")){
                s.push(s.pop()+s.pop());
            }else if(tokens[i].equals("-")){
                int a=s.pop();
                int b=s.pop();
                s.push(b-a);
            }else if(tokens[i].equals("*")){
                s.push(s.pop()*s.pop());
            }else if(tokens[i].equals("/")){
                int c=s.pop();
                int d=s.pop();
                s.push(d/c);
            }else{
                //是数字的情况
                int res=Integer.parseInt(tokens[i]);
                s.push(res);
            }
        }
        return s.pop();
    }
}

239.划定窗口最大值

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回 滑动窗口中的最大值 。

示例 1：

输入：nums = [1,3,-1,-3,5,3,6,7], k = 3
输出：[3,3,5,5,6,7]
解释：
滑动窗口的位置 最大值

---

[1 3 -1] -3 5 3 6 7 3
1 [3 -1 -3] 5 3 6 7 3
1 3 [-1 -3 5] 3 6 7 5
1 3 -1 [-3 5 3] 6 7 5
1 3 -1 -3 [5 3 6] 7 6
1 3 -1 -3 5 [3 6 7] 7

题解：队列的方式实现。队列维护窗口中的值，当窗口向后滑动时，队列先pop然后push。单独写一个比较大小的函数，找出队列中的最大值。用一个单调栈实现上述步骤，保持单调栈的栈口是最大值，当要加入的数大于入口元素时，弹出小元素，当元素小于窗口元素时，直接加入栈中。

确定滑动窗口范围的方法：用数组下标，不在下标范围内，则弹出队列。

代码：

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        int n=nums.length;
        int[] res=new int[n-k+1];
        Deque<Integer> de=new ArrayDeque<>();
        int index=0;
        for(int i=0;i<n;i++){
            //当元素不在滑动窗口范围内
            while(!de.isEmpty() && de.peek()<i-k+1){
                de.poll();
            }
            //保证每次加入的数字比末尾的数小，否则弹出
            while(!de.isEmpty() && nums[de.peekLast()]<nums[i]){
                de.pollLast();
            }
            de.offer(i);
            //达到窗口最大值，添加元素到结果数组
            if(i>=k-1){
                res[index++]=nums[de.peek()];
            }
        }
        return res;
    }
}

347.前K个高频元素

给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。

示例 1:

输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]

**题解：**返回前K个高频元素，怎么计算每个元素出现的次数呢？采用map的key和value的方式，key记录数组值，value记录元素出现的次数。对value进行排序，即能找到前k个高频元素。

怎么对value进行排序可以降低时间复杂度呢？采用大顶堆或是小顶堆的方式，值维护k个元素的顺序，这样时间复杂度是logK,如果全部维护，时间复杂度是kogN。

Map.Entry 是 Java 中用于表示 Map 中每个键值对的接口。它提供了对 Map 中键和值的访问map.entrySet() 是 Java 中 Map 接口的一种方法，它返回一个 Set 视图，包含 Map 中的所有键值对。每个元素都是一个 Map.Entry 对象，代表一个键值对。

代码:

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        int [] res=new int[k];
        Map<Integer,Integer> map=new HashMap<>();
        for(int n:nums){
            map.put(n,map.getOrDefault(n,0)+1);
        }
        //大顶堆实现
        //((n1,n2)->n2[1]-n1[1]) 根据频率进行排序，高频在前，
        //（数组中两个元素，第一个是数组值，第二个是频率）
        PriorityQueue<int[]> pq=new PriorityQueue<>((n1,n2)->n2[1]-n1[1]);
        for(Map.Entry<Integer,Integer> entry:map.entrySet()){
            pq.add(new int[]{entry.getKey(),entry.getValue()});
        }
        for(int i=0;i<k;i++){
            //提取元素
            res[i]=pq.poll()[0];
        }
        return res;
    }
}