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

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

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

⭐️写在前面的话⭐️

📒博客主页： 程序员好冰
🎉欢迎 【点赞👍 关注🔎 收藏⭐️ 留言📝】
📌本文由 程序员好冰 原创，优快云 首发！
📆入站时间： 🌴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

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

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

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

逆波兰表达式
new_gf的博客
05-30 988
逆波兰表达式 首先我们要弄清楚什么是逆波兰表达式？ 对于一个我们常见的算式，例如a+b，我们成为这样的算式为中式表达式，而所谓的逆波兰表达式即是后缀表达式。 读到这，你可能还是不懂，什么是逆波兰表达式，那么我们来说说，对于一个常见的算式，我们怎么用一颗二叉树表示，我们尽量把运算符放在根节点 对于a+b来说，其二叉树的表示方法如下： 所谓逆波兰表达式，就是将这棵树后续遍历得到的结果，即ab+ 而对于a+(b-c)，其二叉树表示形式为： 其后续表达式为abc-+ 从这不就明白了逆波兰表达式吗？ 那么如何进行
【数据结构】——逆波兰表达式
热门推荐
m0_52447591的博客
09-04 1万+
逆波兰表达式简介 假设有一天赵地佐同学（名称纯属虚构，如有雷同，纯属巧合）拿着一道数据极其恐怖的四则运算题找到同班的张三同学，希望他在1s内能给出答案。这时最好的办法是什么呢？当然是不理他，可惜乐于探究的张三同学并不愿意放弃这个机会，于是他拿出了随身携带的笔记本电脑。 为了解决这个问题，让我们尽可能抽象一下四则运算的表达式： ans=A+B/C+(D*E+F)*G 像上面这种符合人们认知习惯自然书写而成的数学表达式称为中缀表达式。但可惜的是，愚蠢的计算...
用栈计算后缀表达式（含两位数）
最新发布
weixin_44720212的博客
03-11 853
后缀表达式，又叫逆波兰表达式是一种数学表达式的方式，其中操作符位于操作数之后，本文介绍了后缀表达式的计算方法和代码实现
利用中缀表达式转后缀表达式实现简易计算器
百里杨的博客
04-06 1096
我们先来了解几个概念 前缀表达式：运算符位于两个相应操作数之前，前缀表达式又被称为前缀记法或波兰式 中缀表达式：是人类最常用的算术表达式，运算符在运算数中间,运算需要考虑运算符优先级 后缀表达式：是计算机容易运算的表达式，运算符在运算数后面,从左到右进行运算,无需考虑优先级,运算呈线性结构 中缀表达式像这样：1 + (2 + 3) × 4 - 5 前缀表达式像这样：- + 1 × +...
逆波兰表达式实现
12-05
逆波兰表达式实现 逆波兰表达式是一种后缀表达式，通常用于表示数学表达式的计算顺序。它的特点是运算符在后面，先计算括号里的运算，然后计算乘除，最后计算加减。逆波兰表达式的实现可以通过栈或队列来实现。 逆...
pta数据结构7-170 逆波兰表达式求值
m0_65588959的博客
10-05 721
pta数据结构
西工大NOJ数据结构理论——021.逆波兰表达式（严7.38）
a15735748145a的博客
05-28 1392
西工大NOJ数据结构理论——021.逆波兰表达式（严7.38）
数据结构之逆波兰表达式
Si_kenn的博客
12-07 884
所谓逆波兰便是反其道而行之.我们一般上的表达式,运算符都是镶嵌在数与数之间的,而逆波兰则独树一帜将运算变成了小尾巴粘到了数字的后面.说起来好像很抽象,还是举个例子吧. 例: 一般表达式 逆波兰表达式 (a + (b - c) * d) / e abc - d * + e / 该表达式的运算顺序: b - c = x x * d = y a + y = z z / e = result 逆波兰采用了栈的先进后出的方式罗列数字与运算符的顺序 第一步将a压入栈中,第二步将b压入,第三步压入c
四则运算（逆波兰表达式求解）
白永辉的专栏
09-10 5566
华为上机测试题中的一个问题。之前很少涉及，不太会。下面是用逆波兰表达式求解的方法。 逆波兰表达式又叫做后缀表达式，它将复杂表达式转换为可以依靠简单的操作得到计算结果的表达式，解决了四则运算中括号改变运算符优先级的问题。 四则运算的表达式一般都是中缀表达式如 1+2*(3-4)
C语言实现逆波兰表达式计算器
在逆波兰表达式中，运算的顺序仅由运算符和操作数的位置决定，不需要使用括号来改变运算的顺序，这使得逆波兰表达式的计算过程非常适合使用栈这一数据结构来实现。栈是一种先进后出（Last In First Out, LIFO）的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值