代码随想录刷题day11丨150. 逆波兰表达式求值，239. 滑动窗口最大值，347.前 K 个高频元素，栈与队列总结-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_75195038/article/details/141503563

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

1.题目

1.1逆波兰表达式求值

题目链接：150. 逆波兰表达式求值 - 力扣（LeetCode）
视频讲解：栈的最后表演！ | LeetCode：150. 逆波兰表达式求值_哔哩哔哩_bilibili
文档讲解：https://programmercarl.com/0150.%E9%80%86%E6%B3%A2%E5%85%B0%E8%A1%A8%E8%BE%BE%E5%BC%8F%E6%B1%82%E5%80%BC.html
解题思路：

代码：

//时间复杂度: O(n)
//空间复杂度: O(n)
class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();
        for(int i = 0;i < tokens.length ;i++){
            if(tokens[i].equals("+")  || tokens[i].equals("-") || tokens[i].equals("*") || tokens[i].equals("/")){
                int num1 = stack.peek();
                stack.pop();
                int num2 = stack.peek();
                stack.pop();
                if(tokens[i].equals("+")){
                    stack.push(num2 + num1);
                }else if(tokens[i].equals("-")){
                    stack.push(num2 - num1);
                }else if(tokens[i].equals("*")){
                    stack.push(num2 * num1);
                }else {
                    stack.push(num2 / num1);
                }
            }else{
                stack.push(Integer.valueOf(tokens[i]));
            }
        }
        return stack.pop();
    }
}

总结：
- 逆波兰表达式（Reverse Polish Notation, RPN）是一种不需要括号的算术表达式表示法，在这种表示法中，操作符位于操作数的后面。它也被称为后缀表达式。
- 例如，常规的中缀表达式 3 + 4 在逆波兰表达式中表示为 3 4 +。而更复杂的表达式如 (3 + 4) * 5 在逆波兰表达式中表示为 3 4 + 5 *。
  
  在计算逆波兰表达式时，按照从左到右的顺序进行操作，当遇到操作符时，应用它于前面的操作数，这种方式避免了使用括号来定义运算顺序。
  
  逆波兰表达式的优点在于它能够简化计算机实现表达式求值的过程，因为它消除了操作符优先级和括号的处理需求。

在这里插入图片描述

逆波兰表达式相当于是二叉树中的后序遍历

1.2滑动窗口最大值

题目链接：239. 滑动窗口最大值 - 力扣（LeetCode）
视频讲解：单调队列正式登场！| LeetCode：239. 滑动窗口最大值_哔哩哔哩_bilibili
文档讲解：https://programmercarl.com/0239.%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3%E6%9C%80%E5%A4%A7%E5%80%BC.html
解题思路：暴力法或者自定义单调队列法
- 暴力法：遍历一遍的过程中每次从窗口中再找到最大的数值，这样很明显是O(n × k)的算法
- 单调队列法：我们需要自定义一个队列，这个队列呢，放进去窗口里的元素，然后随着窗口的移动，队列也一进一出，每次移动之后，队列告诉我们里面的最大值是什么。
  - 这个队列应该长这个样子：
```
class MyQueue {
public:
    void pop(int value) {
    }
    void push(int value) {
    }
    int front() {
        return que.front();
    }
};
```
    - 每次窗口移动的时候，调用que.pop(滑动窗口中移除元素的数值)，que.push(滑动窗口添加元素的数值)，然后que.front()就返回我们要的最大值
  - 其实队列没有必要维护窗口里的所有元素，只需要维护有可能成为窗口里最大值的元素就可以了，同时保证队列里的元素数值是由大到小的。
  - 那么这个维护元素单调递减的队列就叫做单调队列
  - 不要以为实现的单调队列就是对窗口里面的数进行排序，如果排序的话，那和优先级队列又有什么区别呢。
  - 图示

代码：

//时间复杂度: O(n)
//空间复杂度: O(k)
//自定义数组
class MyQueue{
    Deque<Integer> deque = new LinkedList<>();
    //弹出元素时，比较当前要弹出的数值是否等于队列出口的数值，如果相等则弹出
    //同时判断队列当前是否为空
    void popDeque(int val){
        if(!deque.isEmpty() && val == deque.peek()){
            deque.poll();
        }
    }

    void addDeque(int val){
        while(!deque.isEmpty() && val > deque.getLast()){
            deque.removeLast();
        }
        deque.add(val);
    }

    //队列队顶元素始终为最大值
    int maxDeque(){
        return deque.peek();
    }
}


class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums.length == 1){
            return nums;
        }
        int len = nums.length - k + 1;
        //存放结果元素的数组
        int[] res = new int[len];
        int num = 0;
        //自定义队列
        MyQueue myQueue = new MyQueue();
        //先将前K个元素放入队列
        for(int i = 0;i < k;i++){
            myQueue.addDeque(nums[i]);
        }
        res[num] = myQueue.maxDeque();
        num++;
        for(int i = k; i < nums.length;i++){
            myQueue.popDeque(nums[i-k]);
            myQueue.addDeque(nums[i]);
            res[num] = myQueue.maxDeque();
            num++;
        }
        return res;
    }
}

总结：
- MyQueue 类：用来维护一个单调递减的双端队列，从而可以在 O(1) 的时间复杂度内找到当前滑动窗口的最大值。
- Solution 类：通过利用 MyQueue 类，遍历输入数组 nums，在滑动窗口内找到最大值，并将这些最大值存储在结果数组 res 中。算法的时间复杂度为 O(n)，其中 n 是数组的长度。

1.3前 K 个高频元素

题目链接：347. 前 K 个高频元素 - 力扣（LeetCode）
视频讲解：优先级队列正式登场！大顶堆、小顶堆该怎么用？| LeetCode：347.前 K 个高频元素_哔哩哔哩_bilibili
文档讲解：https://programmercarl.com/0347.%E5%89%8DK%E4%B8%AA%E9%AB%98%E9%A2%91%E5%85%83%E7%B4%A0.html
解题思路：
- 要统计元素出现频率
  - 用 map 来进行统计
- 对频率排序
  - 使用一种容器适配器就是优先级队列
- 找出前K个高频元素

代码：

/*Comparator接口说明:
 * 返回负数，形参中第一个参数排在前面；返回正数，形参中第二个参数排在前面
 * 对于队列：排在前面意味着往队头靠
 * 对于堆（使用PriorityQueue实现）：从队头到队尾按从小到大排就是最小堆（小顶堆），
 *                                从队头到队尾按从大到小排就是最大堆（大顶堆）--->队头元素相当于堆的根节点
 * */
class Solution {
    //解法1：基于大顶堆实现
    public int[] topKFrequent1(int[] nums, int k) {
        Map<Integer,Integer> map = new HashMap<>(); //key为数组元素值,val为对应出现次数
        for (int num : nums) {
            map.put(num, map.getOrDefault(num,0) + 1);
        }
        //在优先队列中存储二元组(num, cnt),cnt表示元素值num在数组中的出现次数
        //出现次数按从队头到队尾的顺序是从大到小排,出现次数最多的在队头(相当于大顶堆)
        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++) { //依次从队头弹出k个,就是出现频率前k高的元素
            ans[i] = pq.poll()[0];
        }
        return ans;
    }
    //解法2：基于小顶堆实现
    public int[] topKFrequent2(int[] nums, int k) {
        Map<Integer,Integer> map = new HashMap<>(); //key为数组元素值,val为对应出现次数
        for (int num : nums) {
            map.put(num, map.getOrDefault(num, 0) + 1);
        }
        //在优先队列中存储二元组(num, cnt),cnt表示元素值num在数组中的出现次数
        //出现次数按从队头到队尾的顺序是从小到大排,出现次数最低的在队头(相当于小顶堆)
        PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2) -> pair1[1] - pair2[1]);
        for (Map.Entry<Integer, Integer> entry : map.entrySet()) { //小顶堆只需要维持k个元素有序
            if (pq.size() < k) { //小顶堆元素个数小于k个时直接加
                pq.add(new int[]{entry.getKey(), entry.getValue()});
            } else {
                if (entry.getValue() > pq.peek()[1]) { //当前元素出现次数大于小顶堆的根结点(这k个元素中出现次数最少的那个)
                    pq.poll(); //弹出队头(小顶堆的根结点),即把堆里出现次数最少的那个删除,留下的就是出现次数多的了
                    pq.add(new int[]{entry.getKey(), entry.getValue()});
                }
            }
        }
        int[] ans = new int[k];
        for (int i = k - 1; i >= 0; i--) { //依次弹出小顶堆,先弹出的是堆的根,出现次数少,后面弹出的出现次数多
            ans[i] = pq.poll()[0];
        }
        return ans;
    }
}

总结：
- 什么是优先级队列呢？
  - 其实就是一个披着队列外衣的堆，因为优先级队列对外接口只是从队头取元素，从队尾添加元素，再无其他取元素的方式，看起来就是一个队列。
- 优先级队列内部元素是自动依照元素的权值排列。那么它是如何有序排列的呢？
  - 缺省情况下priority_queue利用max-heap（大顶堆）完成对元素的排序，这个大顶堆是以vector为表现形式的complete binary tree（完全二叉树）。
- 什么是堆呢？
  - 堆是一棵完全二叉树，树中每个结点的值都不小于（或不大于）其左右孩子的值。 如果父亲结点是大于等于左右孩子就是大顶堆，小于等于左右孩子就是小顶堆。
  - 大家经常说的大顶堆（堆头是最大元素），小顶堆（堆头是最小元素），如果懒得自己实现的话，就直接用priority_queue（优先级队列）就可以了，底层实现都是一样的，从小到大排就是小顶堆，从大到小排就是大顶堆。
- 为什么不用快排？
  - 使用快排要将map转换为vector的结构，然后对整个数组进行排序，而这种场景下，我们其实只需要维护k个有序的序列就可以了，所以使用优先级队列是最优的。
- 是使用小顶堆还是大顶堆？
  - 定义一个大小为k的大顶堆，在每次移动更新大顶堆的时候，每次弹出都把最大的元素弹出去了，那么怎么保留下来前K个高频元素呢？
  - 所以我们要用小顶堆，因为要统计最大前k个元素，只有小顶堆每次将最小的元素弹出，最后小顶堆里积累的才是前k个最大元素。

2.栈与队列总结

栈

在这里插入图片描述

栈顶（Top）：线性表允许进行插入删除的那一端。
栈底（Bottom）：固定的，不允许进行插入和删除的另一端。

常用的操作方法包括：

方法	功能
Stack()	构造一个空的栈
E push(E e)	将e入栈，并返回e
E pop()	将栈顶元素出栈并返回
E peek()	获取栈顶元素
int size()	获取栈中有效元素个数
boolean empty()	检测栈是否为空

方法使用举例：

import java.util.Stack;
 
public class StackExample {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<>();
        
        // 压栈操作
        stack.push("Java");
        stack.push("Python");
        stack.push("C++");
        
        // 弹栈操作
        String topLanguage = stack.pop();
        System.out.println("弹出栈顶元素：" + topLanguage);
        
        // 查看栈顶元素
        String currentTop = stack.peek();
        System.out.println("当前栈顶元素：" + currentTop);
        
        // 判空操作
        if (stack.isEmpty()) {
            System.out.println("栈为空");
        } else {
            System.out.println("栈不为空");
        }
    }
}

队列

在这里插入图片描述

队头（Front）：允许删除的一端。
队尾（Rear）：允许插入的一端。
常用的操作方法包括：

方法功能
boolean offer(E e) 入队列
E poll() 出队列
peek() 获取队头元素
int size() 获取队列中有效元素个数
boolean isEmpty() 检测队列是否为空
注意：Queue是个接口，在实例化时必须实例化LinkedList的对象，因为LinkedList实现了Queue接口。

方法	功能
boolean offer(E e)	入队列
E poll()	出队列
peek()	获取队头元素
int size()	获取队列中有效元素个数
boolean isEmpty()	检测队列是否为空

方法使用举例：

public static void main(String[] args) {
    Queue<Integer> q = new LinkedList<>();
    q.offer(1);
    q.offer(2);
    q.offer(3);
    q.offer(4);
    q.offer(5); // 从队尾入队列
    System.out.println(q.size());
    System.out.println(q.peek()); // 获取队头元素
    q.poll();
    System.out.println(q.poll()); // 从队头出队列，并将删除的元素返回
    if(q.isEmpty()){
    System.out.println("队列空");//空就打印“队列空”
    }else{
    System.out.println(q.size());//不空打印元素个数
    }
}

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

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

1.题目

1.1逆波兰表达式求值

1.2滑动窗口最大值

1.3前 K 个高频元素

2.栈与队列总结

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

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