数据结构与算法——Java实现栈、逆波兰计算器（整数加减乘除）

痛定思痛。 2024-03-30 08:56 168阅读 0赞

**目录**

一、栈

1.1 基本介绍

1.2 栈的思路分析

1.3 栈的代码实现

二、栈实现综合计算器

2.1 思路分析

2.2 代码实现（中缀表达式实现）

三、栈的前缀（波兰）、中缀、后缀（逆波兰）表达式

3.1 表达式的介绍

3.2 逆波兰计算器（后缀表达计算器）

3.2.1 思路分析

3.2.2 代码实现

3.3 中缀表达式转后缀表达式

3.3.1 思路分析

3.3.2 代码实现

--------------------

## 一、栈 ##

### 1.1 基本介绍 ###

我们平时使用的计算器，其底层就是利用了栈这个概念对这个算式进行理解

![8b21cadbcc5547cd9e8d3ec61c694ba4.png][]

*  栈的英文为(stack)

*  栈是一个**先入后出**(FILO-First In Last Out)的有序列表

*  (stack)是限制表素的**插入和除只能在性的同一端进行**的一种性表。允许**插入和删除的**

*  **端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)**

*  根据栈的定义可知，**最先放入栈中元素在栈底，最后放入的元素在栈顶**，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除

*  图解方式说明**出栈(pop)和入栈(push)**的概念

![5f9e91082fee414aa0f054ae6af08b23.png][]

**应用场景**

*  **子程序的调用:**在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以可到原来的程序中。
 *  **处理递归调用**:和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。
 *  **表达式的转换**\[中缀表达式转后缀表达式\]与求值(实际解决)。又树的遍历
 *  **图形的深度优先(depth 一 first)搜索法**

###          1.2 栈的思路分析 ###

**我们使用数组模拟栈的使用，由于栈是一种有序列表，那必然可以使用数组的结构来存储栈的数据内容。**

![104787ea38c9460fa987a2b83bf64d29.png][]

### 1.3 栈的代码实现 ###

// 定义一个ArrayStack  表示栈
    class ArrayStack{
        private int maxSize;  //栈的大小
        private int[] stack;  //数组，用数组模拟栈，数据放在数组中
        private int top = -1; //栈顶，初始化为-1
    
    //  栈满
        public boolean isFull(){
            return  top == maxSize-1;
        }
    //  栈空
        public boolean isEmpty(){
            return top ==-1;
        }
    
    //  入栈
        public void push(int value){
            if(isFull()){
    //          栈满的话。不能进栈
                System.out.println("栈满了，不能进栈");
                return;
            }
            top++;
            stack[top] =value;
        }
    
    //  出栈  栈顶数据返回
        public int pop(){
    //        看看是不是空
            if(isEmpty()){
                throw  new RuntimeException("空了，没有数据");
            }
    //       有数据   先运行  再--
            int value = stack[top];
            top--;
            return  value;
    
        }
    
    //   遍历栈  从上往下遍历  只是展示并不出栈
        public void  list(){
            if (isEmpty()){
                System.out.println("栈空，没有数据");
            }
    
            for (int i =top; i>=0;i--){
                System.out.println(stack[i]);
            }
        }
    
    
    
    
    
        public ArrayStack(int maxSize) {
            this.maxSize = maxSize;
            stack = new int[this.maxSize];
        }
    }

## 二、栈实现综合计算器 ##

### 2.1 思路分析 ###

如果这个图看不明白我们直接分析一下就可以了。

![4b75071f62344341be56c78057cf26ab.png][]

**我们分析一个3+2\*6-2这个算式**

① 首先创建一个数栈一个符号栈

② 我们使用index扫描我们的算式。当扫描到“3时”，“3”入栈的时候很显然是进入数栈，此时数栈中的指针指向“3”。

![892d3d55dee147ec90547aced922ecfa.png][]

③ 然后index扫描到“+”号，入符号栈，因为前面没有符号可以比对，所以直接入栈，此时符号栈中的指针指向“+”

![bb7d8368b39742abb63c76526b735e3b.png][]

④ index扫描到“2”，入数栈，指针并且指向“2”

![7286b0c3323146b9996d635698e15a59.png][]

⑤ index扫描到“\*”符号，由于**“\*”符号的运算级比我们栈中存在的“+”运算级要大**，所以**“\*”直接入栈**，并且指针指向“\*”

![c6ef6869f5824cca9517ce44eb2f8897.png][]

⑥ index扫描到“6”，入数栈，指针指向“6”

![10ab8b3c19894b1fa1787531fd6ecf2b.png][]

⑦ index扫描到“-”，然后这个地方很重要，由于**“-”的运算级小于或者等于栈中的操作符（“\*”）**，所以此时要从数栈中pop出两个数据（此时指针指向第二个pop出来的底下的一个位置），然后再从符号栈中pop出一个数据（此时指针移动到符号栈pop位置的底下的位置），进行运算。

但是！！！**我们从数栈中pop出来的两个数的先后顺序会影响我们的结果**，所以应该是pop2\*pop1。让此时的操作结果入数栈（此时指针移动到此结果处）。我们刚刚扫描到的“-”入符号栈（此时指针移动到此符号处）

**运算完成下图**

![38fa1d9d037c445085fa86246c3feff4.png][]

⑧ index扫描到“2”，直接入数栈

![532719527c414913a96c95e68925b860.png][]

⑨ 此时我们也**扫描完毕了，我们按顺序从数栈和符号栈pop出相应的数和符号**，并运行

**数栈弹出两个，符号栈弹出一个**。但是注意，符号栈弹出的两个数一定是有先后顺序的。

**对于此题，当数栈弹出“2”，“12”时，指针应该是指向“3”，等“10”结果入栈后，再指向“10”**

**pop2(12)-pop1(2)=10 这样计算才对 ，此时10应该再入栈**

**当下面两个弹出的时候，数栈中没有东西了，然后计算出结果后，结果入栈，此时数据栈中只有一个元素，便是结果，并且符号栈中没有元素，全部弹出了**

**pop2(3)+pop1(10)=13**

**⑩ 最后数栈只有一个数字，便是表达式的结果**

### 2.2 代码实现（中缀表达式实现） ###

public class Calculator {
        public static void main(String[] args) {
    //     完成表达式运算
            String expression ="70-3-3";
    //     创建两个栈，数栈和
            ArrayStack numStack = new ArrayStack(10);
            ArrayStack operStack = new ArrayStack(10);
    
    //     定义扫描的相关变量  index
            int index=0;
            int num1=0;
            int num2=0;
            int oper=0;
            int res=0;
            char  ch=' '; //每次扫描得到的char保存到ch中
           String keepNum =""; //拼接多位数用的
    
    
    //      开始循环扫描
            while (true){
    //          依次得到expression的每一个字符
    //          截取字符串
                ch = expression.substring(index,index+1).charAt(0);
    
    //          判断是不是符号，如果是符号的话进入符号栈
                if(operStack.isOper(ch)){
    //               如果是运算符的话进入到这里
                    if(!operStack.isEmpty()){
    //               如果符号栈不是空的话，就进行比较，如果当前的操作符的优先级小于或者等于栈中的优先级
    //               就进行从数栈中pop两个，从符号栈pop一个运算，将算处的结果入栈，然后此时index指向的符号入栈
                     if(operStack.priority(ch) <= operStack.priority(operStack.peek())){
    //                   看看谁的优先级高，运行到这里说明我们的ch优先级小于等于符号栈顶部元素的优先级
    //                   从数栈中pop两个，从符号栈pop一个运算，将算处的结果入栈
                         num1 = numStack.pop();
                         num2 = numStack.pop();
                         oper = operStack.pop();
                         res = numStack.cal(num1,num2,oper);
    //                   运算结果入栈
                         numStack.push(res);
    //                   当前index指向的符号入栈
                         operStack.push(ch);
                     }else {
    //                    这种情况就是ch的运算符比,直接入栈
                         operStack.push(ch);
                     }
                    }else {
    //                  如果符号栈是空的话，直接放入符号栈
                        operStack.push(ch);
                    }
                }else {
    //              这种情况是ch是数字，直接放入符号栈
    //                numStack.push(ch); 这样写是错的 我们扫描的到数字其实不是数字，是字符，比如‘3’
    //                  numStack.push(ch-48);  这样写只能算十以内的加减法
    
    //                改进：我们不能发现一个数就入栈，因为可能会有多位数
    //                处理多位数
                    keepNum +=ch;
    //               如果ch已经是表达式的最后一位，直接入栈就行
                    if(index == expression.length()-1){
                        numStack.push( (Integer.parseInt(keepNum)));
                    }else {
    //                  判断下一个字符是不是数字，如果是数字的话就进行拼接
                        if (operStack.isOper(  expression.substring(index+1,index+2).charAt(0)  ) ){
    //                      这个时候后面是操作符，则入栈
                            numStack.push( (Integer.parseInt(keepNum)));
    //                      清空KeepNum
                            keepNum = "";
                        }
                    }
    
    
    
                }
    //          index指针移动
                index++;
    //           index是从0开始的
                if(index >=expression.length()){
    //              已经到最后了
                    break;
                }
            }
    
    //      当表达式扫描完毕，按顺序从数栈和符号栈中取出元素计算
            while (true){
    //        如果符号栈是空，则计算到了最后一步
    //            数栈中只有一个数字
                if(operStack.isEmpty()){
                    break;
                }
                num1 = numStack.pop();
                num2 = numStack.pop();
                oper = operStack.pop();
                res = numStack.cal(num1,num2,oper);
                numStack.push(res);
            }
            System.out.println("结果："+numStack.pop());
            numStack.list();
            operStack.list();
        }
    }
    
    
    // 先创建一个栈
    
    // 定义一个ArrayStack  表示栈
    class ArrayStack {
        private int maxSize;  //栈的大小
        private int[] stack;  //数组，用数组模拟栈，数据放在数组中
        private int top = -1; //栈顶，初始化为-1
    
        public ArrayStack(int maxSize) {
            this.maxSize = maxSize;
            stack = new int[maxSize];
        }
    
    //  看栈顶元素,但不取出
        public int peek(){
            return  stack[top];
        }
    
        //  栈满
        public boolean isFull() {
            return top == maxSize - 1;
        }
    
        //  栈空
        public boolean isEmpty() {
            return top == -1;
        }
    
        //  入栈
        public void push(int value) {
            if (isFull()) {
    //          栈满的话。不能进栈
                System.out.println("栈满了，不能进栈");
                return;
            }
            top++;
            stack[top] = value;
        }
    
        //  出栈  栈顶数据返回
        public int pop() {
    //        看看是不是空
            if (isEmpty()) {
                throw new RuntimeException("空了，没有数据");
            }
    //       有数据   先运行  再--
            int value = stack[top];
            top--;
            return value;
    
        }
    
        //   遍历栈  从上往下遍历  只是展示并不出栈
        public void list() {
            if (isEmpty()) {
                System.out.println("栈空，没有数据");
            }
    
            for (int i = top; i >= 0; i--) {
                System.out.println(stack[i]);
            }
        }
    
    
        //返回运算符的优先级，此优先级由程序员来确定：我们在此规定，数字越大，优先级越高
    //  char和int可以混用
        public int priority(int oper){
    //      假定表达式中只有下面四种符号
            if(oper =='*' || oper == '/'){
                return 1;
            }else if(oper =='+' || oper =='-'){
                return 0;
            }else {
                return -1;
            }
        }
    
    //  判断是不是一个运算符
        public boolean isOper(char var){
            return var=='+' || var =='-' ||var=='*' || var=='/';
        }
    
    //  运算方法
        public int cal(int num1,int num2 , int oper){
            int res = 0;  //res  用于存放计算的结果
            switch (oper){
                case '+':
                    res =num1+num2;
                    break;
                case  '-':
                    res = num2-num1;
                    break;
                case  '*':
                    res = num1*num2;
                    break;
                case  '/':
                    res = num2/num1;
                    break;
                default:
                    break;
            }
            return res;
        }
    
    }

![18ab1068581e4937a96895ca0bf52b06.png][]

## 三、栈的前缀（波兰）、中缀、后缀（逆波兰）表达式 ##

### 3.1 表达式的介绍 ###

**首先说明：不论是哪个表达式，一定要分清出栈的时候是pop1-pop2还是pop2-pop1**

**前缀表达式是pop1-pop2**

**后缀表达式是pop2-pop1 分清减数和被减数 在我们上面的二位数加减乘除代码中，也是pop2-pop1**

**描述**

*  **前缀表达式：波兰表达式，前缀表达式的运算符位于操作数之前**

例如：（3+4）×5-6对应的前缀表达式就是 -×+3 4 5 6

![caa2aa9001a0418d830cbd9f3bdb50fa.png][]

*  **中缀表达式：常见的运算表达式。我们小学学的就是中缀表达式**

**中缀表达式是我们最为熟悉的，但是对于计算机来说却很难操作，因此我们在计算结果的时候，往往会将中缀表达式转换成其他表达式来计算（一般转换成后缀表达式）**

*  **后缀表达式：逆波兰表达式，与前缀表达式相似，知识运算符位于操作数之后**

![18ab92104abe4fa494f1fbee150f09ce.png][]

![df12dad65ded4f46887732b6570b6545.png][]

### 3.2 逆波兰计算器（后缀表达计算器） ###

**要求：支持小括号和多位整数，为了方便我们直接使用系统给我们的栈Stack**

#### 3.2.1 思路分析 ####

我们刚刚看到的那个图就是我们的计算机求值思路

![df12dad65ded4f46887732b6570b6545.png][]

#### 3.2.2 代码实现 ####

public class PolandNotation {
        public static void main(String[] args) {
    //      先定义一个逆波兰表达式，为了方便数字和符号都是用空格间隔开
    //      (3+4)*5-6  后缀表达式就是下面
            String suffixExpression ="3 4 + 5 × 6 -";
    
    //      思路：
    //          1.先将"3 4 + 5 × 6 -"放到ArrayList中
    //          2.将ArrayList传递给一个方法，遍历ArrayList配合栈完成计算
            List<String> rpnList = getListString(suffixExpression);
            System.out.println(calculate(rpnList));
    
    
    
    
        }
    //    将一个逆波兰表达式，依次将数据和运算符放到ArrayList中
        public static List<String> getListString (String suffixExpression){
    //      分割
            String[] split = suffixExpression.split(" ");
            List<String> list = new ArrayList<>();
    //      用这个api更快
            Collections.addAll(list, split);
    
            return list;
    
        }
    
    //  完成对逆波兰表达式的计算，我们已经变成了对List集合的遍历
        public static  int calculate(List<String> ls){
    //      此时只需要一个栈就行了
            Stack<String> stack = new Stack<>();
    //      遍历ls
            for (String item:ls){
                if(item.matches("\\d+")){
    //               入栈
                    stack.push(item);
                }else {
    //               pop出两个数，并运算再入栈
                    int num1 = Integer.parseInt(stack.pop());
                    int num2 = Integer.parseInt(stack.pop());
                    int res=0;
                    if(item.equals("+")){
                        res = num1 + num2;
                    }else if(item.equals("-")){
                        res =num2-num1;
                    }else if(item.equals("×")){
                        res =num1*num2;
                    }else if(item.equals("/")){
                        res = num2/num1;
                    }else {
                        throw new  RuntimeException("运算符有误");
                    }
    //              结果入栈
                    stack.push(res+"");
                }
            }
    //        最后留在stack中的数据是运算结果
            return Integer.parseInt(stack.pop());
            
        }
    
    }

![32f2cd1dc7954ab7a4737b261d6baed4.png][]

### 3.3 中缀表达式转后缀表达式 ###

#### 3.3.1 思路分析 ####

**小括号不是运算符，只是一个改变我们运算顺序的符号**

![3fcf59e9c2e941e4b3857a7e90b00b12.png][]

#### 3.3.2 代码实现 ####

public class PolandNotation {
        public static void main(String[] args) {
    //       完成一个中缀表达式转成后缀表达式的功能
    //      1+((2+3))×4-5  -----> 1 2 3 + 4 × + 5 -
    //      我们对字符串操作不方便，将中缀表达式放入List集合找那个
            String expression = "1+((2+3))×4-5";
    //       转换成对应的list
            List<String>  InfixExpressionList  =toInfixExpressionList(expression);
            System.out.println("中缀表达式的List="+InfixExpressionList);
    //      转换成后缀表达式的List
            List<String> suffixExpressionList  = parseSuffixExpressionList(InfixExpressionList);
            System.out.println("后缀表达式的List"+suffixExpressionList);
            System.out.println("结果:"+ calculate(suffixExpressionList));
    
    
    
        }
    //  将中缀表达式转成对应的List
        public static  List<String> toInfixExpressionList(String s){
    //       定义List存放中缀表达式对应内容
            List<String> ls = new ArrayList<>();
            int i =0;
            String str;  //多位数拼接  因为计算的时候不可能光有一位数
            char c;      // 没遍历一个字符，就放入c中
            do{
                if( (c=s.charAt(i))<48 || (c=s.charAt(i))>57){
    //             运行到这里肯定说明char不是0....9
                   ls.add(""+c);
                   i++;
                }else {
    //              这种情况就是数字了，但是我们需要考虑度多位数
    //              保证是空串
                    str="";
                    while (i<s.length() && (c=s.charAt(i))>=48 && (c=s.charAt(i))<=57 ){
                        str +=c;  //拼接
                        i++;
                    }
                    ls.add(str);
    
                }
    
            }while (i<s.length());
            return  ls;
    
        }
    
    //  中缀表达式转换成后缀表达式
        public static List<String>  parseSuffixExpressionList(List<String> ls){
    //      定义两个栈
            Stack<String> s1 = new Stack<>();  //符号栈
    //      说明：我们s2栈只进栈，只有最后的时候倒序输出，所以我们选择List集合就可以了，方便
            List<String> s2 =new ArrayList<>();//储存中间结果的栈
    
            for(String item:ls){
    //           如果是一个数就进栈s2
                if(item.matches("\\d+")){
    //              遇到操作数时，将其压s2；
                    s2.add(item);
                }else if(item.equals("(")){
    //              如果是左括号“(”，则直接压入s1
                    s1.push(item);
                }else if(item.equals(")")){
    //               如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，
    //               直到遇到左括号为止，此时将这一对括号丢弃
                     while (!s1.peek().equals("(")){
                         s2.add(s1.pop());
                     }
    //               将s1栈的左括号丢掉
                    s1.pop();
    
                }else {
    
    //               这种情况是匹配到字符的时候
    //               优先级比栈顶运算符的高，也将运算符压入s1；
    //               否则（运算符的优先级小于等于），将s1栈顶的运算符弹出并压入到s2中，再与s1中新的栈顶运算符相比较，如果遇到空栈或者（，直接进栈
                    while (s1.size() !=0 && Operation.getValue(s1.peek()) >= Operation.getValue(item)){
                        s2.add(s1.pop());
                    }
    //               出循环的话，item的运算符肯定比顶部的高或者栈空了
    //               优先级比栈顶运算符的高，也将运算符压入s1；
                    s1.push(item);
    //                if(s1.peek()==null || Operation.getValue(item)>Operation.getValue(s1.peek())){
    //                    s1.push(item);
    //                }
                }
            }
    
    //       将s1中剩余的运算符依次弹出并压入s2
            while (s1.size()!=0){
                s2.add(s1.pop());
            }
    //      因为是存放到列表里面，就不需要逆序输出了，现在已经是逆序表达式
            return s2;
    
        }
    
    
    //    将一个逆波兰表达式，依次将数据和运算符放到ArrayList中
        public static List<String> getListString (String suffixExpression){
    //      分割
            String[] split = suffixExpression.split(" ");
            List<String> list = new ArrayList<>();
    //      用这个api更快
            Collections.addAll(list, split);
    
            return list;
    
        }
    
    //  完成对逆波兰表达式的计算，我们已经变成了对List集合的遍历
        public static  int calculate(List<String> ls){
    //      此时只需要一个栈就行了
            Stack<String> stack = new Stack<>();
    //      遍历ls
            for (String item:ls){
                if(item.matches("\\d+")){
    //               入栈
                    stack.push(item);
                }else {
    //               pop出两个数，并运算再入栈
                    int num1 = Integer.parseInt(stack.pop());
                    int num2 = Integer.parseInt(stack.pop());
                    int res=0;
                    if(item.equals("+")){
                        res = num1 + num2;
                    }else if(item.equals("-")){
                        res =num2-num1;
                    }else if(item.equals("×")){
                        res =num1*num2;
                    }else if(item.equals("/")){
                        res = num2/num1;
                    }else {
                        throw new  RuntimeException("运算符有误");
                    }
    //              结果入栈
                    stack.push(res+"");
                }
            }
    //        最后留在stack中的数据是运算结果
            return Integer.parseInt(stack.pop());
    
        }
    
    }
    
    
    
    class Operation{
        private static int ADD=1;  //加
        private static int SUB=1;  //减
        private static int MUL=2;  //乘
        private static int DIV=2;  //除
    
    //   写方法返回对应的优先级数字
        public static  int getValue(String operation){
            operation= operation.trim();
    
            int result =0;
            switch (operation){
                case "+":
                    result =ADD;
                    break;
                case "-":
                    result = SUB;
                    break;
                case "×":
                    result=MUL;
                    break;
                case "/":
                    result =DIV;
                    break;
                default:
                    System.out.println(operation);
                    System.out.println("不存在该运算符");
                    break;
            }
            return result;
        }
    
    }

[8b21cadbcc5547cd9e8d3ec61c694ba4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/da35f473aee34336abb24e599ef1e935.png
[5f9e91082fee414aa0f054ae6af08b23.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/d5605f01781d415caf322893fe07ff20.png
[104787ea38c9460fa987a2b83bf64d29.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/9976ada7c680497187b14e7698b0d420.png
[4b75071f62344341be56c78057cf26ab.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/60c407ab98834e2c869efbb15d5d5a1a.png
[892d3d55dee147ec90547aced922ecfa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/8977e960ddf84c0585bc8c6b1971a2b9.png
[bb7d8368b39742abb63c76526b735e3b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/c872069122db43d092287911f210d756.png
[7286b0c3323146b9996d635698e15a59.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/4e36bf78888a4aceacde4d64795d8776.png
[c6ef6869f5824cca9517ce44eb2f8897.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/d07dde5e55594d2f8709c5fb304b81c8.png
[10ab8b3c19894b1fa1787531fd6ecf2b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/a0da3d3aebdd4f1b8f79a42a9a11d710.png
[38fa1d9d037c445085fa86246c3feff4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/5d4932ccb1fc464b9007f2bc8250e003.png
[532719527c414913a96c95e68925b860.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/029c95b9728746b5b6f31ae823243c04.png
[18ab1068581e4937a96895ca0bf52b06.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/65ed63ee22d74625b12519b18e46ba2c.png
[caa2aa9001a0418d830cbd9f3bdb50fa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/2d73c14931ca4a88a53921aea3040186.png
[18ab92104abe4fa494f1fbee150f09ce.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/5782440e9df04ad98d0e19af3fc175bc.png
[df12dad65ded4f46887732b6570b6545.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/1ce7ffac9c2e475f8934941c47aa376d.png
[32f2cd1dc7954ab7a4737b261d6baed4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/41f2ac0883774442ad79792076957c50.png
[3fcf59e9c2e941e4b3857a7e90b00b12.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/2f51713924244ba2abae197bf7179649.png