代码随想录：栈与队列02

代码随想录打卡博客

逆波兰表达式求值

本题的思路即是通过一个栈来存储每一个值，然后当遇到符号的时候就将前两个数字出栈，运算后的结果入栈，数字直接入栈，最后栈返回结果值。

代码如下：

import java.util.Stack;

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();
        for(String s : tokens){
            if(s.equals("+")){
                stack.push(stack.pop()+stack.pop());
            }else if(s.equals("-")){
                stack.push(-stack.pop()+stack.pop());
            }else if ((s.equals("*"))) {
                stack.push(stack.pop()*stack.pop());
            }else if(s.equals("/")){
                int temp1 = stack.pop();
                int temp2 = stack.pop();
                stack.push(temp2/temp1);
            }else{
                stack.push(Integer.valueOf(s));
            }
        }
        return stack.pop();
    }
}

滑动窗口最大值

本题思路要有一个有序的递增队列，然后一个数组存放结果。队列中放数组下标，当下标小于滑动窗口最小值时，将其移除队列中，然后如果要加入的下标的值大于队列尾下标代表的值那么将队尾元素移除。

代码如下：

import java.util.ArrayDeque;
import java.util.Deque;

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        Deque<Integer> deque = new ArrayDeque<>();
        int n = nums.length;
        int[] res = new int[n - k + 1];
        int idx = 0;
        for(int i = 0;i < n;i++){
            while (!deque.isEmpty() && deque.peek() < i - k + 1) {
                deque.poll();
            }
            while (!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
                deque.pollLast();
            }
            deque.offer(i);
            if(i >= k - 1){
                res[idx++] = nums[deque.peek()];
            }
        }
        return res;
    }
}

前K个高频元素

本题感觉比较难。首先是需要一个map来存储出现的数字以及其频率。然后需要一个小顶堆，也是优先级队列。
将map中的键值对放入其中，维持其中k个高频元素。

代码如下：

import java.util.HashMap;
import java.util.Map;
import java.util.PriorityQueue;

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        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()){
            if(pq.size() < k){
                pq.add(new int[]{entry.getKey(),entry.getValue()});
            }else{
                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;
    }
}