【数据结构】逆波兰表达式

于 2023-04-03 16:35:59 发布
阅读量226 收藏
点赞数 1
文章标签： 数据结构 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67689541/article/details/129933131
版权
本文介绍了如何使用逆波兰表达式（后缀表达式）来计算中缀表达式的值。首先，通过栈结构将中缀表达式转换为后缀表达式，然后遍历后缀表达式计算其值。代码实现了处理数字、运算符和括号的功能，但不支持大括号和中括号，且限制为处理整数和两位数的表达式。
摘要由CSDN通过智能技术生成

文章目录

⭐️写在前面的话⭐️

📒博客主页： 程序员好冰
🎉欢迎 【点赞👍 关注🔎 收藏⭐️ 留言📝】
📌本文由 程序员好冰 原创，CSDN 首发！
📆入站时间： 🌴2022 年 07 月 13 日🌴
✉️ 是非不入松风耳，花落花开只读书。
💭推荐书籍：📚《Java编程思想》，📚《Java 核心技术卷》
💬参考在线编程网站：🌐牛客网🌐力扣
🍭 作者水平很有限，如果发现错误，一定要及时告知作者哦！感谢感谢！🍭

逆波兰表达式

代码只实现了小括号的匹配，大括号和中括号的匹配没有实现；

只能够实现整数类型的表达式运算；

只限处理两位数的表达式，两位数以上的没有实现。

0、构建基本的栈结构

#include <stdio.h>
#include <stdlib.h>
#include<string.h>

#define OK 1
#define ERROR 0

#define MAX_SIZE 100

typedef char ElemType;
typedef int Status;

typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode;

typedef struct LinkStack
{
    int count;
    struct LNode *top;
}LinkStack;

Status InitStack(LinkStack* L)
{
    L->top=(LNode*)malloc(sizeof(LNode));
    if(!L->top){
        return ERROR;
    }
    L->top=NULL;
    L->count=0;
    return OK;
}

Status StackIsEmpty(LinkStack L)
{
    if(L.count==0){
        return OK;
    }
    if(L.count!=0){
        return ERROR;
    }
    return OK;
}

ElemType GetTop(LinkStack L)
{
    if(StackIsEmpty(L)){
        return ERROR;
    }
    return L.top->data;
}

Status Push(LinkStack *L,ElemType e)
{
    LNode *s=(LNode*)malloc(sizeof(LNode));
    s->data=e;
    s->next=L->top;
    L->top=s;
    L->count++;
    return OK;
}

LNode* Pop(LinkStack *L)
{
    if(StackIsEmpty(*L)){
        return ERROR;
    }
    LNode *temp;
    temp=L->top;
    L->top=L->top->next;
    L->count--;
    return temp;
}

Status PrintStack(LinkStack L)
{
    if(L.top==NULL){
        return ERROR;
    }
    while(L.top){
        printf("%c",L.top->data);
        L.top=L.top->next;
    }
    printf("\n");
    return OK;
}

1、中缀表达式转为后缀表达式

准备一个存放运算结果的数组和一个判断操作符的栈

从左往右扫描表达式

遇到数字，直接存入数组中；

遇到运算符，

​ 首先解决分母为0的问题，

​ 再判断栈如果为空，直接入栈，

​ 栈不为空，比较该运算符和此时栈顶元素的优先级

​ 高于，直接入栈；低于，依次出栈，直到高于栈顶元素的优先级；

遇到左括号，直接入栈；

遇到右括号，依次将栈顶元素存入数组，遇到左括号结束，再将左括号弹出；

最后表达式遍历完毕，依次将栈中的元素弹出存入数组中。

image-20230403142321916

1.1封装需要的方法

//判断输入的字符是否为数值
int is_Number(char c)
{
    if(c>='0'&&c<='9'){
        return 1;
    }
    return 0;
}

//判断输入的字符是否为运算符
int is_Operator(char c)
{
    if(c=='+'||c=='-'||c=='*'||c=='/'){
        return 1;
    }
    return 0;
}

//比较加减乘除的优先级
/*加减的优先级为1;乘除的优先级为2*/
int comp_Priority(char c)
{
    int level=0;
    switch(c)
    {
        case '+':
        case '-':
            level=1;
            break;
        case '*':
        case '/':
            level=2;
            break;
    }
    return level;
}

//判断是否为左括号
int is_Left(char c)
{
    if(c=='('){
        return 1;
    }
    return 0;
}

//判断是否为右括号
int is_Right(char c)
{
    if(c==')'){
        return 1;
    }
    return 0;
}

//初始化数组，每一位都放‘/0’
char result[MAX_SIZE]={0};

//存放后缀表达式的数组
void input(char c)
{
    static int index=0;
    result[index++]=c;
}

1.2 主方法

//将中缀表达式转换为后缀表达式
Status Trans_Postfix_Notation(char *str)
{
    int i;
    //初始化一个符号工作栈
    LinkStack L;
    InitStack(&L);
    i=0;
    while(str[i]!='\0'){
        //情况1:是数字
        if(is_Number(str[i])){
            if(is_Number(str[i+1])){
                input(str[i]);
            }
            //后一个可能是运算符或者括号
            if(!is_Number(str[i+1])){
                input(str[i]);
                input(' ');
            }
        }
        //情况2:是运算符
        /*如果栈为空，运算符直接压栈*/
        /*如果栈为不为空，要进栈的运算符与栈顶运算符比较优先级*/
        /*优先级高，继续压栈*/
        /*优先级低，出栈*/
        if(is_Operator(str[i])){
            if(str[i]=='/'&&str[i+1]=='0'){
                printf("表达式中分母不能为0.\n");
                return ERROR;
            }
            if(!StackIsEmpty(L)){
                    //比较优先级
                    /*1、要压入的，比栈顶的高,直接压入*/

                    /*2、要压入的，比栈顶的低*/
                    if(comp_Priority(str[i])<=comp_Priority(GetTop(L))){
                        while(!StackIsEmpty(L)&&comp_Priority(str[i])<=comp_Priority(GetTop(L))){
                            input(Pop(&L)->data);
                            input(' ');
                        }
                    }
                   Push(&L,str[i]);//两种情况公有的部分
                }
            if(StackIsEmpty(L)){
               Push(&L,str[i]);
              }
        }

        //情况3:是左括号
        if(is_Left(str[i])){
            Push(&L,str[i]);
        }

        //情况4:是右括号
        if(is_Right(str[i])){
            while(!is_Left(GetTop(L))){
                input(Pop(&L)->data);
                input(' ');
                if(StackIsEmpty(L)){
                    printf("表达式的括号不匹配.\n");
                    return ERROR;
                }
            }
            Pop(&L);//弹出匹配的左括号
        }

        //情况5:非法字符
        if(!is_Number(str[i])&&!is_Operator(str[i])&&!is_Left(str[i])&&!is_Right(str[i])){
            printf("存在非法字符.\n");
            return ERROR;
        }
        i++;
    }

    //情况6:字符串循环完毕
    while(!StackIsEmpty(L)){
        input(Pop(&L)->data);
        input(' ');
    }

    printf("%s",result);
    return OK;
}

2、计算后缀表达式的值

从左往右扫描表达式，

遇到数字就将其压入栈，注意如果是两位数，需要多取一次

遇到运算符说明可以计算，这时取出依次取出栈顶的两个元素进行运算符运算，

运算完毕，将计算结果再压入栈

直到栈中只留下最后一个元素

这个元素就是表达式的计算结果。

2.1 封装需要的方法

//将字符串转为整型
int string_to_int(char *temp)
{
    return atoi(temp);
}

//将字符类型转为整型
int char_to_int(char temp)
{
    return temp-'0';
}

//将整型转为字符类型
char int_to_char(int temp)
{
    return temp+'0';
}

int Calculator(int a,int b,char temp)
{
    int result2=0;
    switch(temp)
    {
    case '+':
        result2=a+b;
        break;
    case '-':
        result2=a-b;
        break;
    case '*':
        result2=a*b;
        break;
    case '/':
        result2=a/b;
        break;
    }
    return result2;
}

2.2 主方法

int comp_Rev_Polish_Notation()
{
    LinkStack S;//存放
    InitStack(&S);
    int i=0;
    int sum=0;//记录最终的结果
    int a,b;//需要进行运算的两个操作数
    int c;//保留两数的计算结果
    while(result[i]!='\0'){
        if(result[i]!=' '){
            if(is_Number(result[i])){
                if(!is_Number(result[i+1])){
                    Push(&S,result[i]);
                }
                if(is_Number(result[i+1])){//解决两位数的问题
                    a=char_to_int(result[i]);
                    b=char_to_int(result[i+1]);
                    c=a*10+b;
                    Push(&S,int_to_char(c));
                    i+=2;
                    continue;
                }
            }
            if(is_Operator(result[i])){
                a=char_to_int(Pop(&S)->data);
                b=char_to_int(Pop(&S)->data);
                c=Calculator(b,a,result[i]);
                Push(&S,int_to_char(c));
            }
        }
        i++;
    }
    if(S.count==1){
        sum=char_to_int(Pop(&S)->data);
    }
    return sum;
}

3、主函数

int main()
{
    char str[MAX_SIZE]={0};//存放手动输入的中缀表达式
    char ch;
    int i=0;
    int sum=0;//记录表达式的最终结果
    printf("链栈创建成功,请继续操作.\n");
    printf("\n==========================\n");
    printf("通过逆波兰表示法计算表达式的值.\n");
    printf("请输入一个中缀表达式:");
    while((ch=getchar())!='\n'){
        str[i]=ch;
        i++;
    }
    str[i]='\0';
    printf("\n");
    printf("对应的后缀表达式(逆波兰表达式)为:");
    Trans_Postfix_Notation(str);
    printf("\n");
    printf("\n");
    sum=comp_Rev_Polish_Notation();
    printf("表达式的值为:%d.\n",sum);
    printf("\n");
    printf("==========================\n");
    return 0;
}

程序源码

#include <stdio.h>
#include <stdlib.h>
#include<string.h>

#define OK 1
#define ERROR 0

#define MAX_SIZE 100

typedef char ElemType;
typedef int Status;

typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode;

typedef struct LinkStack
{
    int count;
    struct LNode *top;
}LinkStack;

Status InitStack(LinkStack* L)
{
    L->top=(LNode*)malloc(sizeof(LNode));
    if(!L->top){
        return ERROR;
    }
    L->top=NULL;
    L->count=0;
    return OK;
}

Status StackIsEmpty(LinkStack L)
{
    if(L.count==0){
        return OK;
    }
    if(L.count!=0){
        return ERROR;
    }
    return OK;
}

ElemType GetTop(LinkStack L)
{
    if(StackIsEmpty(L)){
        return ERROR;
    }
    return L.top->data;
}

Status Push(LinkStack *L,ElemType e)
{
    LNode *s=(LNode*)malloc(sizeof(LNode));
    s->data=e;
    s->next=L->top;
    L->top=s;
    L->count++;
    return OK;
}

LNode* Pop(LinkStack *L)
{
    if(StackIsEmpty(*L)){
        return ERROR;
    }
    LNode *temp;
    temp=L->top;
    L->top=L->top->next;
    L->count--;
    return temp;
}

Status PrintStack(LinkStack L)
{
    if(L.top==NULL){
        return ERROR;
    }
    while(L.top){
        printf("%c",L.top->data);
        L.top=L.top->next;
    }
    printf("\n");
    return OK;
}

/*--------------------------------*/

//判断输入的字符是否为数值
int is_Number(char c)
{
    if(c>='0'&&c<='9'){
        return 1;
    }
    return 0;
}

//判断输入的字符是否为运算符
int is_Operator(char c)
{
    if(c=='+'||c=='-'||c=='*'||c=='/'){
        return 1;
    }
    return 0;
}

//比较加减乘除的优先级
/*加减的优先级为1;乘除的优先级为2*/
int comp_Priority(char c)
{
    int level=0;
    switch(c)
    {
        case '+':
        case '-':
            level=1;
            break;
        case '*':
        case '/':
            level=2;
            break;
    }
    return level;
}

//判断是否为左括号
int is_Left(char c)
{
    if(c=='('){
        return 1;
    }
    return 0;
}

//判断是否为右括号
int is_Right(char c)
{
    if(c==')'){
        return 1;
    }
    return 0;
}

//初始化数组，每一位都放‘/0’
char result[MAX_SIZE]={0};

//存放后缀表达式的数组
void input(char c)
{
    static int index=0;
    result[index++]=c;
}


//将中缀表达式转换为后缀表达式
Status Trans_Postfix_Notation(char *str)
{
    int i;
    //初始化一个符号工作栈
    LinkStack L;
    InitStack(&L);
    i=0;
    while(str[i]!='\0'){
        //情况1:是数字
        if(is_Number(str[i])){
            if(is_Number(str[i+1])){
                input(str[i]);
            }
            //后一个可能是运算符或者括号
            if(!is_Number(str[i+1])){
                input(str[i]);
                input(' ');
            }
        }
        //情况2:是运算符
        /*如果栈为空，运算符直接压栈*/
        /*如果栈为不为空，要进栈的运算符与栈顶运算符比较优先级*/
        /*优先级高，继续压栈*/
        /*优先级低，出栈*/
        if(is_Operator(str[i])){
            if(str[i]=='/'&&str[i+1]=='0'){
                printf("表达式中分母不能为0.\n");
                return ERROR;
            }
            if(!StackIsEmpty(L)){
                    //比较优先级
                    /*1、要压入的，比栈顶的高,直接压入*/

                    /*2、要压入的，比栈顶的低*/
                    if(comp_Priority(str[i])<=comp_Priority(GetTop(L))){
                        while(!StackIsEmpty(L)&&comp_Priority(str[i])<=comp_Priority(GetTop(L))){
                            input(Pop(&L)->data);
                            input(' ');
                        }
                    }
                   Push(&L,str[i]);//两种情况公有的部分
                }
            if(StackIsEmpty(L)){
               Push(&L,str[i]);
              }
        }

        //情况3:是左括号
        if(is_Left(str[i])){
            Push(&L,str[i]);
        }

        //情况4:是右括号
        if(is_Right(str[i])){
            while(!is_Left(GetTop(L))){
                input(Pop(&L)->data);
                input(' ');
                if(StackIsEmpty(L)){
                    printf("表达式的括号不匹配.\n");
                    return ERROR;
                }
            }
            Pop(&L);//弹出匹配的左括号
        }

        //情况5:非法字符
        if(!is_Number(str[i])&&!is_Operator(str[i])&&!is_Left(str[i])&&!is_Right(str[i])){
            printf("存在非法字符.\n");
            return ERROR;
        }
        i++;
    }

    //情况6:字符串循环完毕
    while(!StackIsEmpty(L)){
        input(Pop(&L)->data);
        input(' ');
    }

    printf("%s",result);
    return OK;
}

//封装的函数

//将字符串转为整型
int string_to_int(char *temp)
{
    return atoi(temp);
}

//将字符类型转为整型
int char_to_int(char temp)
{
    return temp-'0';
}

//将整型转为字符类型
char int_to_char(int temp)
{
    return temp+'0';
}

int Calculator(int a,int b,char temp)
{
    int result2=0;
    switch(temp)
    {
    case '+':
        result2=a+b;
        break;
    case '-':
        result2=a-b;
        break;
    case '*':
        result2=a*b;
        break;
    case '/':
        result2=a/b;
        break;
    }
    return result2;
}

int comp_Rev_Polish_Notation()
{
    LinkStack S;//存放
    InitStack(&S);
    int i=0;
    int sum=0;//记录最终的结果
    int a,b;//需要进行运算的两个操作数
    int c;//保留两数的计算结果
    while(result[i]!='\0'){
        if(result[i]!=' '){
            if(is_Number(result[i])){
                if(!is_Number(result[i+1])){
                    Push(&S,result[i]);
                }
                if(is_Number(result[i+1])){//解决两位数的问题
                    a=char_to_int(result[i]);
                    b=char_to_int(result[i+1]);
                    c=a*10+b;
                    Push(&S,int_to_char(c));
                    i+=2;
                    continue;
                }
            }
            if(is_Operator(result[i])){
                a=char_to_int(Pop(&S)->data);
                b=char_to_int(Pop(&S)->data);
                c=Calculator(b,a,result[i]);
                Push(&S,int_to_char(c));
            }
        }
        i++;
    }
    if(S.count==1){
        sum=char_to_int(Pop(&S)->data);
    }
    return sum;
}


int main()
{
    char str[MAX_SIZE]={0};//存放手动输入的中缀表达式
    char ch;
    int i=0;
    int sum=0;//记录表达式的最终结果
    printf("链栈创建成功,请继续操作.\n");
    printf("\n==========================\n");
    printf("通过逆波兰表示法计算表达式的值.\n");
    printf("请输入一个中缀表达式:");
    while((ch=getchar())!='\n'){
        str[i]=ch;
        i++;
    }
    str[i]='\0';
    printf("\n");
    printf("对应的后缀表达式(逆波兰表达式)为:");
    Trans_Postfix_Notation(str);
    printf("\n");
    printf("\n");
    sum=comp_Rev_Polish_Notation();
    printf("表达式的值为:%d.\n",sum);
    printf("\n");
    printf("==========================\n");
    return 0;
}

运行截图

image-20230403163016851

🚀先看后赞，养成习惯！🚀

🚀 先看后赞，养成习惯！🚀

🎈觉得文章写得不错的老铁们，点赞评论关注走一波！谢谢啦！🎈

程序员好冰
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
逆波兰表达式
ANSWER 的专栏
11-26 899
 逆波兰表达式 rpn（Reverse Polish Notation）　　逆波兰表达式，它的语法规定，表达式必须以逆波兰表达式的方式给出。逆波兰表达式又叫做后缀表达式。这个知识点在数据结构和编译原理这两门课程中都有介绍，下面是一些例子：　　正常的表达式 逆波兰表达式　　a+b a,b,+　　a+(b-c) a,b,c,-,+　　a+(b-c)*d a,d,b,c,-,*,+
利用中缀表达式转后缀表达式实现简易计算器
百里杨的博客
04-06 969
我们先来了解几个概念 前缀表达式：运算符位于两个相应操作数之前，前缀表达式又被称为前缀记法或波兰式 中缀表达式：是人类最常用的算术表达式，运算符在运算数中间,运算需要考虑运算符优先级 后缀表达式：是计算机容易运算的表达式，运算符在运算数后面,从左到右进行运算,无需考虑优先级,运算呈线性结构 中缀表达式像这样：1 + (2 + 3) × 4 - 5 前缀表达式像这样：- + 1 × +...
逆波兰表达式实现
12-05
逆波兰表达式实现 逆波兰表达式是一种后缀表达式，通常用于表示数学表达式的计算顺序。它的特点是运算符在后面，先计算括号里的运算，然后计算乘除，最后计算加减。逆波兰表达式的实现可以通过栈或队列来实现。 逆...
逆波兰表达式求值
12-22
3. **栈数据结构**：后进先出（LIFO）的数据结构，适合处理逆波兰表达式，因为它遵循运算符先于操作数的规则。 4. **字典映射**：通过字典将运算符映射到对应的函数，简化了运算过程。 5. **列表推导式**：虽然这里...
逆波兰表达式.cpp
03-26
逆波兰表达式的长 度不超过一行，以 "$"作为输入结束，操作数之间用空格分隔，操作符只可能有＋、—、＊、／四种 运算。例如： 23434 + 2*$。 数据结构作业
Python实现处理逆波兰表达式示例
09-20
逆波兰表达式的计算原理是利用栈这一数据结构。当遍历表达式时，遇到数字或变量就将其压入栈中；遇到运算符时，弹出栈顶的两个元素进行运算，然后将运算结果重新压入栈中。遍历完整个表达式后，栈中剩余的唯一元素...
C++代码实现逆波兰表达式
12-16
本文实例为大家分享了C++实现逆波兰表达式的具体代码，供大家参考，具体内容如下 当我们输入一个数学表达式，是中缀表达式，我们首先转换为后缀表达式（逆波兰表达式），然后再进行求值。 在《大话数据结构》的104-...
逆波兰表达式 题解
Error0 Blog·错误零
08-08 713
【题目描述】 逆波兰表达式是一种把运算符前置的算术表达式，例如普通的表达式2 + 3的逆波兰表示法为+ 2 3。逆波兰表达式的优点是运算符之间不必有优先级关系，也不必用括号改变运算次序，例如(2 + 3) 4的逆波兰表示法为 + 2 3 4。本题求解逆波兰表达式的值，其中运算符包括+ - * /四个。 【输入】 输入为一行，其中运算符和运算数之间都用空格分隔，运算数是浮点数。 【输出】 输出为一行...
【数据结构】——逆波兰表达式
热门推荐
m0_52447591的博客
09-04 1万+
逆波兰表达式简介 假设有一天赵地佐同学（名称纯属虚构，如有雷同，纯属巧合）拿着一道数据极其恐怖的四则运算题找到同班的张三同学，希望他在1s内能给出答案。这时最好的办法是什么呢？当然是不理他，可惜乐于探究的张三同学并不愿意放弃这个机会，于是他拿出了随身携带的笔记本电脑。 为了解决这个问题，让我们尽可能抽象一下四则运算的表达式： ans=A+B/C+(D*E+F)*G 像上面这种符合人们认知习惯自然书写而成的数学表达式称为中缀表达式。但可惜的是，愚蠢的计算...
逆波兰表达式+数据结构
最新发布
10-11
逆波兰表达式是一种将中缀表达式转换为后缀表达式的方法，它可以方便地进行计算。具体来说，逆波兰表达式将操作符放在操作数的后面，从而避免了使用括号和优先级规则。例如，中缀表达式 "3 + 4 * 2 / ( 1 - 5 )" ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值