day11 栈与队列part02-CSDN博客

150. 逆波兰表达式求值

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

239. 滑动窗口最大值

要使用数据结构 deque，方便操作队首、队尾

数组中的坐标，举例来确定。

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

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        // 总共有nums.length - k + 1 个 长度为k的窗口
        int[] result = new int[nums.length - k + 1];
        Deque<Integer> deque = new ArrayDeque<>();
        int index = 0;
        for(int i = 0; i < nums.length; i++){
            // peek 小于 k的窗口时，出队列，  例如i = k时，  0的位置就不在k窗口中
            while(!deque.isEmpty() && deque.peek() < i - k + 1){
                deque.poll();
            }
            // 队列中从后开始，小于当前值的， 也出队列。
            while(!deque.isEmpty() && nums[deque.getLast()] < nums[i]){
                deque.pollLast();
            }
            deque.offer(i);
            // i从k-1开始往结果里填数。   
            if(i >= k - 1){
                result[index++] = nums[deque.peek()];
            }
        }
        return result;

    }
}

347.前 K 个高频元素

先统计频率，再安排进入队列的顺序。

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.HashMap;
import java.util.Map;
import java.util.Stack;

class Solution {

    public int[] topKFrequent(int[] nums, int k) {
        Map<Integer, Integer> map = new HashMap<>();
        Deque<Integer> deque = new ArrayDeque<>();
        Stack<Integer> stack = new Stack<>();
        // 统计出现频率
        for(int num : nums){
            map.put(num, map.getOrDefault(num, 0) + 1);
        }
        for(int key : map.keySet()){
            // 队列中小于当前值频率的，   出队列，进栈。  
            while(!deque.isEmpty() && map.get(deque.getLast()) < map.get(key)){
                stack.push(deque.pollLast());
            }
            if(deque.size() < k){
                // 队列小于k, 如队列， 然后把栈中元素进队列。
                deque.offer(key);
                while(deque.size() < k && !stack.isEmpty()){
                    deque.offer(stack.pop());
                }
            }
        }
        int index = 0;
        int[] result = new int[k];
        while(!deque.isEmpty() && index < k){
            result[index++] = deque.pollFirst();
        }
        return result;
    }
}