代码随想录算法day11||栈与队列part02||150. 逆波兰表达式求值，239. 滑动窗口最大值，347.前 K 个高频元素

150. 逆波兰表达式求值

Deque<Integer> stack = new LinkedList<>();

• 数据结构: LinkedList 实现了 Deque 接口，Deque（双端队列）允许在两端进行插入和删除操作。
• 接口: Deque 接口提供了栈和队列的操作方法，使得 LinkedList 可以同时用作栈和队列。
• 线程安全性: LinkedList 和 Deque 接口都不是线程安全的。如果需要线程安全的栈操作，可以使用 Collections.synchronizedDeque(new LinkedList<>())。
• 功能性: Deque 提供了比 Stack 更丰富的操作方法。例如，Deque 提供了 addFirst、addLast、removeFirst、removeLast 等方法，可以更灵活地操作双端队列。
• 推荐用法: 一般来说，使用 Deque 代替 Stack 是更好的选择，因为 Deque 是 Java Collections Framework 中的一部分，并且提供了更好的设计。

2. Stack<Integer> stack = new Stack<>();

• 数据结构: Stack 是一个继承自 Vector 的类，具有栈的特性（后进先出，LIFO）。
• 线程安全性: Stack 是线程安全的，因为它继承自 Vector，而 Vector 的方法是同步的。但是这种同步机制是比较粗粒度的，可能影响性能。
• 过时建议: 虽然 Stack 类仍然存在并可用，但它在现代 Java 编程中不推荐使用。官方建议使用 Deque 来代替 Stack。
• 功能性: Stack 类的方法比较简单，仅提供了基本的栈操作，如 push、pop、peek 等。

总结

• 如果你需要一个现代、高效且功能更丰富的栈实现，建议使用 Deque<Integer> stack = new LinkedList<>(); 或者 Deque<Integer> stack = new ArrayDeque<>();（ArrayDeque 通常比 LinkedList 更高效）。
• 如果你需要线程安全的栈实现，可以考虑使用 Collections.synchronizedDeque(new LinkedList<>()) 或者使用其他同步机制，如 ConcurrentLinkedDeque。
• Stack 类虽然仍然可用，但在现代 Java 编程中不推荐使用。

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

    }
}

239. 滑动窗口最大值

class myQueue{
    Deque<Integer> max_record=new LinkedList<>();
    void poll(int val){
        if(!max_record.isEmpty()&&val==max_record.peek()){
            max_record.poll();
        }
    }
    // void push(int val){
    //     if(!max_record.isEmpty()&&max_record.getLast()<val){
    //         max_record.removeLast();
    //     }
    //     max_record.addLast(val);
    // }
    void push(int val) {
        while (!max_record.isEmpty() && val > max_record.getLast()) {
            max_record.removeLast();
        }
        max_record.add(val);
    }
    int peek() {
        return max_record.peek();
    }
    @Override
    public String toString() {
        return "myQueue{" +
                "max_record=" + max_record +
                '}';
    }

}

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if (nums.length == 1) {
            return nums;
        }
        int len=nums.length-k+1;
        myQueue max_record=new myQueue();
        int[] result = new int[len];
        
        for(int i=0;i<k;i++){
            max_record.push(nums[i]);
        }
        System.out.println(max_record);
        result[0]=max_record.peek();
        for(int i=k;i<nums.length;i++){
            max_record.poll(nums[i-k]);
            max_record.push(nums[i]);
            result[i-k+1]=max_record.peek();
            System.out.println(max_record);
        }
        return result;

    }
}

347.前 K 个高频元素

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        Map<Integer,Integer> map = new HashMap<>(); //key为数组元素值,val为对应出现次数
        for (int num : nums) {
            map.put(num, map.getOrDefault(num,0) + 1);
        }
        PriorityQueue<int[]> pq=new PriorityQueue<>((pair1,pair2)->pair2[1]-pair1[1]);

        for(Map.Entry<Integer,Integer> entry:map.entrySet()){
            pq.add(new int[]{entry.getKey(),entry.getValue()});
        }
        int[] ans = new int[k];
        for(int i=0;i<k;i++){
            ans[i]=pq.poll()[0];
        }
        return ans;
    }
}