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

150.逆波兰表达式求值

该题目逆波兰式就是后缀表达式，后缀表达式的计算是最方便的，使用栈，每当出现运算符，就弹出两个数计算并放回。

Integer转String

 //方法一:Integer类的静态方法toString()
 Integer a = 2;
 String str = Integer.toString(a)
 ​
 //方法二:Integer类的成员方法toString()
 Integer a = 2;
 String str = a.toString();
 ​
 //方法三:String类的静态方法valueOf()
 Integer a = 2;
 String str = String.valueOf(a);

String转Integer

 String str = "111";
 Integer i = Integer.valueof(str);

代码如下：

 class Solution {
     public int evalRPN(String[] tokens) {
         Stack<Integer> stk = new Stack<>();
         // 波兰式就是前缀表达式，逆波兰式是后缀表达式
         for(String s : tokens){
             if("+".equals(s)){
                 stk.push(stk.pop() + stk.pop());
             }else if("-".equals(s)){
                 stk.push(-stk.pop() + stk.pop());
             }else if("*".equals(s)){
                 stk.push(stk.pop() * stk.pop());
             }else if("/".equals(s)){
                 int num1 = stk.pop();
                 int num2 = stk.pop();
                 stk.push(num2 / num1);
             }
             else{
                 stk.push(Integer.valueOf(s));
             }
         }
         return stk.pop();
     }
 }

239.滑动窗口最大值

deque的api

add() offer() 两者的区别是add空间不足会抛异常，offer不会抛异常，会返回false

addFirst() addLast()

peekFirst() peekLast()

pollFirst() pollLast()

该题目的解题思路：

自己创建一个单调队列，维护一个单调递减的队列。

 class MyQueue{
     Deque<Integer> deque = new LinkedList<>();
     void poll(int value){
         // 看看这个值是否是最大值，如果是的话弹出，不是就什么都不做
         if(!deque.isEmpty() && deque.peek() == value){
             deque.poll();
         }
     }
     void add(int value){
         // 看看队列中是否有比他小的值，有就删，一直删到不比他小为止
         while(!deque.isEmpty() && value > deque.getLast()){
             deque.removeLast();
         }
         deque.add(value);
     }
     int peek(){
         // 查看当前最大值
         return deque.peek();
     }
 }
 ​
 class Solution {
     public int[] maxSlidingWindow(int[] nums, int k) {
         // 自己写的队列
         MyQueue myQueue = new MyQueue();
         int[] ans = new int[nums.length - k + 1];
         for(int i = 0; i < k; i++){
             myQueue.add(nums[i]);
         }
         int j = 0;
         ans[j++] = myQueue.peek();
         for(int i = k; i < nums.length; i++){
             myQueue.poll(nums[i - k]);
             myQueue.add(nums[i]);
             ans[j++] = myQueue.peek();
         }
         return ans;
     }
 }

347.前K个高频元素

最直观的想法是，通过map去统计词频，然后再对map进行排序，这里选择Stream流操作对其进行排序。

 class Solution {
     public int[] topKFrequent(int[] nums, int k) {
         HashMap<Integer,Integer> nMap = new HashMap<>();
         for(int i : nums){
             if(!nMap.containsKey(i)){
                 nMap.put(i,1);
             }
             else{
                 nMap.put(i,nMap.get(i) + 1);
             }
         }
         Map<Integer,Integer> sortedMap = nMap.entrySet().stream()
                 .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
                 .collect(Collectors.toMap(
                         Map.Entry::getKey,
                         Map.Entry::getValue,
                         (oldVal, newVal) -> oldVal,
                         LinkedHashMap::new
                 ));
         int[] ans = new int[k];
         int j = 0;
         for(Map.Entry<Integer,Integer> t : sortedMap.entrySet()){
             if(k-- > 0)
             ans[j++] = t.getKey();
         }
         return ans;
     }
 }