数据结构（Java）学习笔记——知识点：前缀、中缀、后缀表达式

已于 2023-06-16 02:16:29 修改
阅读量922 收藏 6
点赞数
分类专栏： 数据结构笔记 文章标签： java 数据结构 学习
于 2023-06-16 02:14:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44699157/article/details/131230199
版权
文章介绍了数据结构中前缀（波兰表达式）、中缀和后缀（逆波兰表达式）表达式的基本概念，并提供了Java代码实现逆波兰计算器。中缀表达式通常用于人类阅读，而计算通常使用后缀表达式。文章还详细阐述了中缀表达式转后缀表达式的步骤，并给出相关代码示例。
摘要由CSDN通过智能技术生成

数据结构（Java）学习笔记——知识点：前缀、中缀、后缀表达式

八、前、中、后缀表达式

1、前缀表达式（波兰表达式）

 a、前缀表达式的运算符位于操作数之前
　b、举例：( 3 + 4 ) * 5 - 6 对应的前缀表达式应为为 - * + 3 4 5 6
　
　在前缀表达式中，是从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对他们进行相应的计算（栈顶元素和次栈顶元素），并将结果入栈；重复上述过程，直到表达式的最左端，最后算出的值就是表达式的结果。
　
　上述表达式求值的步骤如下：
　Ⅰ、从右至左扫描，将 6、5、4、3 压入堆栈。
　Ⅱ、遇到 + 运算符，弹出 3 和 4 （3 为栈顶元素，4为次栈顶元素），计算出 3 + 4 的结果， 为 7，再将 7 入栈。
　Ⅲ、接下来进行 * 的运算，弹出 7 和 5 ，计算出得 7 * 5 = 35，再将 35 入栈。
　Ⅳ、最后时 - 运算符，计算出 35 - 6 的值，得到29，输出最终结果。

2、中缀表达式

 中缀表达式，就是我们人看到的数学表达式，例：( 3 + 4 ) * 5 - 6 。对人类友好，对二进制的硅基大脑是不友好的。在计算时，一般都转换成后缀表达式进行操作。

3、后缀表达式（逆波兰表达式）

 a、后缀表达式与前缀表达式相似，就是运算符位于操作数之后。
　b、举例：( 3 + 4 ) * 5 - 6 对应的后缀表达式是 3 4 + 5 * 6 -
　c、再比如
　在这里插入图片描述
 在后缀表达式中，是从左至右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对他们进行相应的计算（栈顶元素和次栈顶元素），并将结果入栈；重复上述过程，直到表达式的最右端，最后算出的值就是表达式的结果。
　
 上述表达式求值的步骤如下：
　Ⅰ、从左至右扫描，将 3 和 4 压入堆栈。
　Ⅱ、遇到 + 运算符，弹出 4 和 3 （4 为栈顶元素，3为次栈顶元素），计算出 3 + 4 的结果， 为 7，再将 7 入栈。
　Ⅲ、将 5 压入栈
　Ⅳ、接下来进行 * 的运算，弹出 5 和 7 ，计算出得 7 * 5 = 35，再将 35 入栈。
　Ⅴ、将6入栈
　Ⅵ、最后时 - 运算符，计算出 35 - 6 的值，得到29，输出最终结果。（注意！此时注意减数和被减数的顺序！！！）

4、逆波兰计算器

需求如下

 1)输入一个逆波兰表达式（后缀表达式），使用栈(Stack)，计算结果
　2)支持小括号和多位数整数，这里只做简易的计算，所以只用整数就行。
　3)思路分析
　4)完成代码
　
　一个小时的头脑风暴下，我终于写了出来。方法不唯一，这里我只写了和上一段代码相似的代码。其实也可以用内置剪切方法 split（）来写。

代码实现

package com.database.stack;

public class PolandNotation {
    public static void main(String[] args) {
        //首先定义一个计算公式
        //(3+4)*5-6 => 3 4 + 5 * 6 -
        String suffixExpression = "3 4 + 5 * 6 - ";
        Poland poland = new Poland(suffixExpression.length());
        int index = 0;//定义一个下标
        int num1 = 0;
        int num2 = 0;
        int res = 0;
        char ch = ' ';
        String str = "";
        while(true){
            //跳出循环
            if(index >= suffixExpression.length()){
                break;
            }
            ch = suffixExpression.substring(index,index + 1).charAt(0);
            if(ch == ' '){
                index++;
                continue;
            }else{
                if(!poland.isOper(ch)){
                    //插入数字
                    if(str == ""){
                        str += ch;
                    }
                    //判断如果下一个元素不是符号
                    if(!poland.isOper(suffixExpression.substring(index + 1,index + 2).charAt(0))){
                        //如果不是符号,就拼接到str后面
                        str += ch;
                        index++;
                        continue;
                    }
                    poland.push(Integer.parseInt(str));
                    str = "";
                }else{
                    //如果是符号，就取出刚刚入栈的数，进行计算，然后再放入栈中
                    num1 = poland.pop();
                    num2 = poland.pop();
                    res = poland.cal(num1,num2,ch);
                    poland.push(res);
                }
            }
            index++;
        }
        System.out.println("最终计算结果为：" + res);
    }
}
class Poland{
    private int maxSize;//栈的大小
    private int[] stack;//定义一个数组，因为我们要用数组来实现栈。
    private int top = -1;//初始状态下，将top置于数组的顶端。
    //编写一个构造器,声明变量的同时就生成长度

    public Poland(int maxSize){
        this.maxSize = maxSize;
        stack = new int[maxSize];//根据maxSize来生成一个数组
    }

    //判断栈满,因为栈是从下标为0开始的，所以栈满时正好是 maxSize - 1
    public boolean isFull(){
        return top == maxSize - 1;
    }

    //判栈空
    public boolean isEmpty(){
        return top == -1;
    }

    //入栈 push
    public void push(int value){
        if (isFull()){
            System.out.println("栈是满的！");
            return ;
        }
        top++;//top先自加再往里面填值
        stack[top] = value;
    }

    //出站 pop
    public int pop(){
        int value = 0;
        if(isEmpty()){
            System.out.println("栈是空的！");
            return 0;
        }
        value = stack[top];
        top--;
        return value;
    }

    //遍历栈的时候是从栈顶开始遍历的 栈顶的下标值为top
    public void list(){
        if(isEmpty()){
            System.out.println("栈是空的！");
            return ;
        }
        for(int i = top; i >= 0; i--){
            System.out.println( stack[i] + " ");
        }
    }

    //判断是个运算符还是一个数字
    public boolean isOper(char val){
        return val == '+' || val == '-' || val == '*' || val == '/' || val == ' ';
    }

    //一个计算方法
    public int cal(int num1, int num2, char oper){
        int res = 0;//定义一个res接收结果
        switch (oper){
            case '+':
                res = num1 + num2;
                break;
            case '-'://注意顺序
                res = num2 - num1;
                break;
            case '*':
                res = num1 * num2;
                break;
            case '/':
                res = num1 / num2;
                break;
            default:
                break;
        }
        return res;
    }
}

运行结果

在这里插入图片描述

5、中缀表达式转后缀表达式

具体步骤

 1）初始化两个栈：运算符栈s1和存储中间结果的栈s2
　2）从左到右扫描中缀表达式
　3）遇到数字，压入s2
　4）遇到运算符，比较其与s1栈顶运算符的优先级
　　a、如果s1为空，或栈顶运算符为"（"，则直接把此运算符入栈。
　　b、否则，如果优先级比栈顶运算符的高，也将此运算符入栈。
　　c、否则，将s1栈顶的运算符弹出，并压入到s2中，再次转到4-a中与s1中的栈顶运算符相比较。
　5）如果遇到括号时：
　　a、如果时左括号“（”，则直接压入s1
　　b、如果时右括号“）”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
　6）重复步骤2到5，直到表达式的最右边
　7）将s1中剩余的运算符依次弹出并压入s2
　8）依次弹出s2中的元素并输出，结果的逆序就是中缀表达式对应的后缀表达式

 举例：1 + ( ( 2 + 3 ) * 4 ) - 5　==> 　1 2 3 + 4 * + 5 -
 在这里插入图片描述

代码实现

package com.database.stack;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class PolandNotation {
    public static void main(String[] args) {
        //完成将一个中缀表达式转后缀表达式的功能
        //说明
        //1、1+((2+3)*4)-5 => 1 2 3 + 4 * + 5 -
        String infixExpriession = "1+((2+3)*4)-5";
        InfixExpression s1 = new InfixExpression(infixExpriession.length());
        InfixExpression s2 = new InfixExpression(infixExpriession.length());
        int subscript = 0;
        char element = ' ';
        String number = "";
        while(true){
            //如果遍历到最后一个数，直接跳出循环
            if(subscript >= infixExpriession.length()){
                break;
            }
            element = infixExpriession.substring(subscript,subscript + 1).charAt(0);

            if(s1.isOper(element)){
                //如果element的值是一个运算符
                //如果s1为空，或栈顶运算符为"（"，则直接把此运算符入栈。
                if(s1.isEmpty() || s1.peek() == '('){
                    s1.push(element);
                }else if(s1.priority(element) > s1.priority(s1.peek())){
                    //否则，如果优先级比栈顶运算符的高，也将此运算符入栈。
                    s1.push(element);
                }else{
                    //否则，将s1栈顶的运算符弹出，并压入到s2中，再次转到4-a中与s1中的栈顶运算符相比较。
                    s2.push(s1.pop());
                    continue;
                }
            }else if(s1.isBracket(element)){
                //如果输入的是括号
                if(element == '('){
                    //如果是左括号
                    s1.push(element);
                }else{
                    //如果时右括号“）”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号**丢弃**
                    while (true){
                        if(s1.peek() == '('){
                            s1.pop();
                            break;
                        }
                        s2.push(s1.pop());
                    }
                }
            }else{
                //如果element的值是一个数字,压入s2
                if(number == ""){
                    number += element;
                }
                //如果运行到最后一个字符的时候
                if(subscript == infixExpriession.length() - 1){
                    s2.push(Integer.parseInt(number));
                    break;
                }
                if(!s2.isOper(infixExpriession.substring(subscript + 1,subscript +2).charAt(0))){
                    if(!s2.isBracket(infixExpriession.substring(subscript + 1,subscript +2).charAt(0))){
                        number += element;
                        subscript++;
                        continue;
                    }
                }
                s2.push(Integer.parseInt(number));
                number = "";
                //s2.push(element);
            }
            subscript++;
        }

        //将s1中剩余的运算符依次弹出并压入s2
        while(true){
            if(s1.isEmpty()){
                break;
            }
            s2.push(s1.pop());
        }

        //定义一个数组
        List<Object> list = new ArrayList<Object>();
        while(true) {
            if (s2.isEmpty()) {
                break;
            }
            int temp = s2.pop();

            if((temp + '0') < 60){
                list.add((char)(temp + '0'));
                continue;
            }
            list.add((char)temp);
        }

        //倒序输出
        Collections.reverse(list);
        System.out.println("生成的后缀表达式为：" + list);


        //首先定义一个计算公式
        //(3+4)*5-6 => 3 4 + 5 * 6 -
        String suffixExpression = "3 4 + 5 * 6 - ";
        Poland poland = new Poland(suffixExpression.length());
        int index = 0;//定义一个下标
        int num1 = 0;
        int num2 = 0;
        int res = 0;
        char ch = ' ';
        String str = "";
        while(true){
            //跳出循环
            if(index >= suffixExpression.length()){
                break;
            }
            ch = suffixExpression.substring(index,index + 1).charAt(0);
            if(ch == ' '){
                index++;
                continue;
            }else{
                if(!poland.isOper(ch)){
                    //插入数字
                    if(str == ""){
                        str += ch;
                    }
                    //判断如果下一个元素不是符号
                    if(!poland.isOper(suffixExpression.substring(index + 1,index + 2).charAt(0))){
                        //如果不是符号,就拼接到str后面
                        str += ch;
                        index++;
                        continue;
                    }
                    poland.push(Integer.parseInt(str));
                    str = "";
                }else{
                    //如果是符号，就取出刚刚入栈的数，进行计算，然后再放入栈中
                    num1 = poland.pop();
                    num2 = poland.pop();
                    res = poland.cal(num1,num2,ch);
                    poland.push(res);
                }
            }
            index++;
        }
        System.out.println("最终计算结果为：" + res);
    }
}

class InfixExpression{
    private int maxSize;//栈的大小
    private int[] stack;//定义一个数组，因为我们要用数组来实现栈。
    private int top = -1;//初始状态下，将top置于数组的顶端。

    //构造器
    public InfixExpression(int maxSize){
        this.maxSize= maxSize;
        stack = new int[maxSize];
    }

    //判断栈满,因为栈是从下标为0开始的，所以栈满时正好是 maxSize - 1
    public boolean isFull(){
        return top == maxSize - 1;
    }

    //判栈空
    public boolean isEmpty(){
        return top == -1;
    }

    //怎加一个，返回栈顶的值的方法
    public int peek(){
        return stack[top];
    }

    //入栈 push
    public void push(int value){
        if (isFull()){
            System.out.println("栈是满的！");
            return ;
        }
        top++;//top先自加再往里面填值
        stack[top] = value;
    }

    //出站 pop
    public int pop(){
        int value = 0;
        if(isEmpty()){
            System.out.println("栈是空的！");
            return 0;
        }
        value = stack[top];
        top--;
        return value;
    }

    //判断运算符优先级的方法,数字越大，优先级越高
    public int priority(int oper){
        if(oper == '*' || oper == '/'){
            return 1;
        }else if(oper == '+' || oper == '-'){
            return 0;
        }else{
            return -1;
        }//目前假定只有 + - * / 这四个运算
    }

    //遍历栈的时候是从栈顶开始遍历的 栈顶的下标值为top
    public void list(){
        if(isEmpty()){
            System.out.println("栈是空的！");
            return ;
        }
        for(int i = top; i >= 0; i--){
            System.out.println( stack[i] + " ");
        }
    }

    //判断是个运算符还是一个数字
    public boolean isOper(char val){
        return val == '+' || val == '-' || val == '*' || val == '/';
    }

    //判断是否为括号
    public boolean isBracket(char val){
        return val == ')' || val == '(';
    }
}

class Poland{
    private int maxSize;//栈的大小
    private int[] stack;//定义一个数组，因为我们要用数组来实现栈。
    private int top = -1;//初始状态下，将top置于数组的顶端。
    //编写一个构造器,声明变量的同时就生成长度

    public Poland(int maxSize){
        this.maxSize = maxSize;
        stack = new int[maxSize];//根据maxSize来生成一个数组
    }

    //判断栈满,因为栈是从下标为0开始的，所以栈满时正好是 maxSize - 1
    public boolean isFull(){
        return top == maxSize - 1;
    }

    //判栈空
    public boolean isEmpty(){
        return top == -1;
    }

    //入栈 push
    public void push(int value){
        if (isFull()){
            System.out.println("栈是满的！");
            return ;
        }
        top++;//top先自加再往里面填值
        stack[top] = value;
    }

    //出站 pop
    public int pop(){
        int value = 0;
        if(isEmpty()){
            System.out.println("栈是空的！");
            return 0;
        }
        value = stack[top];
        top--;
        return value;
    }

    //遍历栈的时候是从栈顶开始遍历的 栈顶的下标值为top
    public void list(){
        if(isEmpty()){
            System.out.println("栈是空的！");
            return ;
        }
        for(int i = top; i >= 0; i--){
            System.out.println( stack[i] + " ");
        }
    }

    //判断是个运算符还是一个数字
    public boolean isOper(char val){
        return val == '+' || val == '-' || val == '*' || val == '/' || val == ' ';
    }

    //一个计算方法
    public int cal(int num1, int num2, char oper){
        int res = 0;//定义一个res接收结果
        switch (oper){
            case '+':
                res = num1 + num2;
                break;
            case '-'://注意顺序
                res = num2 - num1;
                break;
            case '*':
                res = num1 * num2;
                break;
            case '/':
                res = num1 / num2;
                break;
            default:
                break;
        }
        return res;
    }
}

 这段代码是有毛病的，只能运算解析9以内的表达式。可以用转换数组的方式进行完善，这里主要是描述思路，请有空闲时间自行完成。

宇直不会放弃
关注
专栏目录
考研系列-数据结构冲刺课复习笔记（上）
Nelson_hehe的博客
08-25 236
本文是王道408数据结构课程的冲刺知识点笔记（上半部分），包括线性表、栈、队列、字符串、树、图章节。
Java中的中缀式、前缀式及后缀式
TingtingYang
07-15 1270
Java中的中缀式、前缀式及后缀式1. 前缀表达式2. 后缀表达式3. 具体步骤 1. 前缀表达式 指的是不包含括号，运算符放在两个运算对象的前面，严格从右向左进行（不再考虑运算符的优先规则），所有的计算按运算符出现的顺序。 2. 后缀表达式 指的是不包含括号，运算符放在两个运算对象的后面，所有的计算按运算符出现的顺序，严格从左向右进行（不再考虑运算符的优先规则）。 　　由于后缀表达式的运算符在两...
前中后缀表达式
qq_41552331的博客
02-11 922
一、前缀表达式 1、运算符在前，操作数在后的表达式 2、前缀表达式的计算机求值 从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算(栈顶元素和次顶元素)，并将结果入栈;重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果 例如: (3+4)X5-6对应的前缀表达式就是-X +3456,针对前缀表达式求值步骤如下: 1)从右至左扫描...
Java-数据类型
最新发布
weixin_60440423的博客
07-29 118
当使用float需要再数值后面加上F作为后缀，否则报错。当使用long需要再数值后面加上L作为后缀，否则报错。1、数据类型分为：基本数据类型、引用数据类型。默认整数int,浮点数是double。2、整数、浮点数、字符、布尔。
前缀、中缀、后缀表达式
热门推荐
Antineutrino的专栏
09-09 18万+
关键字：概念, 前缀表达式, 前缀记法, 中缀表达式, 中缀记法, 波兰式, 后缀表达式, 后缀记法, 逆波兰式 它们都是对表达式的记法，因此也被称为前缀记法、中缀记法和后缀记法。它们之间的区别在于运算符相对与操作数的位置不同：前缀表达式的运算符位于与其相关的操作数之前
数据结构学习（C++）——栈应用（表达式求值） (转)
05-25
// 输出后缀表达式：234*+62/- return 0; } ``` ### 2.2 后缀表达式求值的实现 后缀表达式求值也可以使用栈来实现。具体的代码实现如下： ```cpp #include #include #include using namespace std; // ...
数据结构学习笔记（3.栈，队列，数组 4.串）
super_song的博客
05-04 1190
文章目录第三章 栈，队列和数组栈（stack）顺序栈的实现 第三章 栈，队列和数组 栈（stack） 栈的定义 只允许在一端进行插入或删除操作的线性表 重要术语：栈顶，栈底，空栈 栈的基本操作 创建，销毁，进栈，出栈， 栈的常考题型 可能是先全部进栈，再出栈；也可能是边进边出； 可能的出栈顺序的排列组合为卡特兰数，了解即可 考试多数出选择题，选出可能的情况 知识点小结 栈是一种进出受限的线性表 顺序栈的实现 ...
数据结构笔记NO.1（绪论、线性表、栈队列和矩阵的压缩存储）
qq_43544430的博客
06-04 3816
数据结构学习笔记
【专栏必读】王道考研408数据结构+计算机算法设计与分析万字笔记、题目题型总结、注意事项、目录导航和思维导图
快乐江湖的博客
11-23 4万+
各位老铁思维导图在我整理完笔记后会放上去的，我需要根据王道的思维导图重新再做一遍 文章目录一：有关注意事项二：关于专栏三：学习建议四：各专栏导航（各位老铁别催，质量优先）（1）第一章：绪论（2）第二章：线性表（3）第三章：栈和队列第四章：串第五章：二叉树第六章：图 首先感谢王道大大（手动比心），很用心在做了，大家可以看其中两节是否符合胃口 (王道408考研数据结构)第五章树-第三节1：二叉树遍历（先序、中序和后序） (王道408考研数据结构)第五章树-第四节2：平衡二叉树(AVL)及其旋转 一：有.
中缀表达式转后缀表达式_前、中、后缀表达式
weixin_39890633的博客
12-03 94
#前缀表达式（波兰表达式）前缀表达式又称为波兰式，前缀表达式的运算符位于操作数之前举例：（3+4）*5-6对应的波兰式是-*+3456前缀表达式的计算求值从右到左扫描表达式，将数字压入堆栈遇到运算符时，弹出栈顶的两个数，进行运算注意顺序为：栈顶元素 -操作符->次顶元素并将结果入栈；重复上述过程直到表达式最右端最后运算得出的值即为最终结果例如 （3+4）*5-6对应的波兰式是-*+3456从...
后缀表达式Java
klzgr19870401_2017的博客
06-20 507
package com.huawei.crj.huawei.postfix; import java.util.Stack; public class PostfixCalcutor { /* 1.如果是数字或者空格则输出 2.如果是符号则入栈 */ public static long calcPostfix(String src) { ...
后缀表达式（java实现）
qqqqq1993qqqqq的博客
08-02 1342
意外地求后缀表达式的笔试题挺多的一个对于一个单行的逆波兰表达式，由如下元素构成： 数字：十进制数字字符构成的正整数，比如 223 运算符：支持三种运算符^+和*，分别代表自增，加法和乘法 分隔符：一个或者多个空格 例如下面的字符串就是个逆波兰表达式 2 3 4 * ^ 5 + 逆波兰表达式在一个基于栈的虚拟机中求解，虚拟机的栈能保存16个整数，虚拟机从左向右扫描表达式，遇到整数就压栈，
前缀、中缀、后缀表达式及其求值
aibaiwu6038的博客
02-26 519
它们都是对表达式的记法，因此也被称为前缀记法、中缀记法和后缀记法。它们之间的区别在于运算符相对与操作数的位置不同：前缀表达式的运算符位于与其相关的操作数之前；中缀和后缀同理。 比如： (4 + 5) × 6- 7 就是中缀表达式 - × + 4567 前缀表达式 45 + 6×7 - 后缀表达式 中缀表达式（中缀记法） 中缀表达式是一种通用的算术或逻辑公式表示方法，操作...
Java之前缀和算法
qq_64580912的博客
02-22 2890
前缀和,顾名思义,就是前n项相加之和,和我们高中时候学习的数列中的一个含义例如一个等差数组=n,那他的前n项和也可知道。相当于外层循环确定end,内层循环确定开始的位置start的位置 其实我们可以用一个哈希表进行优化,因为它的前缀和每次都是叠加的,其实只要统计它的每个前缀和的次数,然后prefix-k就是它从0到start的前缀和,此时start+1到end的位置就是和为k的子数组,同时map哈希表刚开始的时候还要添加key=0,value=1的键值对,因为当prefix刚好为k的时候,prefix-k
后缀表达式实现（java)
weixin_47433564的博客
02-23 1082
这里写自定义目录标题一、思路二、实现三、总结 一、思路 后缀表达式：操作符放到操作对象后面 实现思路：（与前缀表达式实现思路有点相似） 1、将字符串切割，并用一个字符串数组接收 2、索引从左到右开始扫描 3、如果为数字则入栈，为运算符就将数栈弹出两个数字进行运算，将结果压入栈 4、重复2、3，直至到右边边界 二、实现 import java.util.Stack; public class ReversePolishDemo {
后缀表达式 Java实现
design1234的博客
07-10 229
基本原理： 　　从左到右扫描字符串：1、是操作数：压栈。　　2、是操作符：出栈两个操作数，将运算结果压栈。 扫描字符串通过java.util.Scanner类实现，其next方法可以读取以空格（默认）或指定符号分割的元素。 算法代码： 1 public class PostfixEvaluator{ 2 private final...
JAVA数据结构与算法-前缀、中缀、后缀表达式
qq_45677613的博客
08-09 1051
介绍前缀、中缀、后缀表达式，中缀转后缀方法，设计后缀表达式计算器
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

宇直不会放弃

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值