C++堆栈应用（二）：后缀表达式求值

最新推荐文章于 2024-09-27 11:26:03 发布
最新推荐文章于 2024-09-27 11:26:03 发布
阅读量3.4k 收藏 18
点赞数 5
文章标签： c++ 数据结构 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MilkLeong/article/details/104199637
版权

在日常生活中，我们接触到的算术表达式多为中缀表达式，其一般形式为：
5+6/2-3*4
即运算符位于两个参与运算的运算数的中间。
而在计算机对算术表达式求值时，却多是基于后缀表达式来进行求值。前面的中缀表达式转化为后缀表达式后，其形式为：
5 6 2 / + 3 4 * -
即运算符紧跟参与运算的两个运算数之后。

本文是关于如何在CodeBlocks编辑器中，用C++语言实现后缀表达式求值，所参考的代码来源于浙大陈越、何钦铭所编的《数据结构(第2版)》(高等教育出版社，2016)，P71-81.
下文是对关键代码的阐释。

1.GetOp()函数：读入运算符或运算数
从后缀表达式中读入一个对象（运算数或运算符），并将其保存、返回。
GetOp()函数的三个形参参数：
1.char *Expr 是指向后缀表达式(一个字符数组)的字符指针；
2.int *index 是指示后缀表达式(字符数组)下标的整型指针；
3.char *str 是指向保存所读对象(运算数或运算符)的字符指针。

Type GetOp(char *Expr,int *index,char *str)
{
    int i=0;

    while((str[i]=Expr[(*index)++])==' '); //跳过后缀表达式前的空格
    while(str[i]!=' ' && str[i]!='\0'){
        str[++i]=Expr[(*index)++];  //将后缀表达式中的运算数或运算符存入str[]数组中
    }
    if(str[i]=='\0')
        (*index)--;  //如果读到后缀表达式的结尾，使下标停在结束符处
    str[i]='\0';   //写入结束标志

    if(i==0)                 //判断是否读到后缀表达式的结束
        return end;
    else if(isdigit(str[0])) //判断str[]中存入的是否为运算数
        return num;
    else                    //判断str中是否存的运算符
        return opr;
}

GetOp()函数的返回值为一个枚举类型的对象，该类型的定义为：

enum Type{num,opr,end};

类型名为Type，其中num,opr,end这三个枚举常量分别对应运算符、运算数、字符串结尾

2.PostfixExp()函数：调用GetOp()函数，读入后缀表达式并求值

ElementType PostfixExpr(char *Expr)
{
    Stack sta,*S;
    S=&sta;
    Type T;
    ElementType Op1,Op2;
    char str[MaxSize];
    int index=0;

    InitStack(S);
    Op1=Op2=0;
    /*当未读到结束标识符时*/
    while((T=GetOp(Expr,&index,str))!=end){
        if(T==num)  //如果读到运算数，存入栈顶
            Push(S,atof(str));

        else{      //如果读到运算符，从栈中弹出最上面两个元素进行运算
            if(S->top!=-1)
                Op2=Pop(S);
            else
                Op2=INFINITY; //标记异常
            if(S->top!=-1)
                Op1=Pop(S);
            else
                Op2=INFINITY;
            switch(str[0]){
                case '+':Push(S,Op1+Op2);break;
                case '-':Push(S,Op1-Op2);break;
                case '*':Push(S,Op1*Op2);break;
                case '/':{
                    if(Op2!=0.0)
                        Push(S,Op1/Op2);
                    else{
                        cout<<"错误：分母除法为0"<<endl;
                    }
                    break;
                }
                default:cout<<"未知运算符"<<str[0]<<endl;Op2=INFINITY;break;
            }
            if(Op2>=INFINITY)
                break;    //若标记异常，退出while()循环
        }

    }
    if(Op2<INFINITY)  //若读数过程无异常
        if(S->top!=-1)
            Op2=Pop(S);
        else
            Op2=INFINITY;
    delete S;
    return(Op2);
}

这个函数有几处需要说明：
（1）Op2=INFINITY
Op1和Op2分别表示参与一次四则远算的两个运算数，例如在“4/2”的除法运算中，Op1=4，Op2=2。作者用Op2=INFINITY语句来标志在读入后缀表达式的过程中遇到异常（例如运算符数目异常、运算符为±*/之外的其他符号、被除数为0等）。INFINITY代表正无穷：

#define INFINITY 1e9

（2）isdigit()函数
该函数属于ctype.h标准库，若要调用该函数，需要在头文件中写入：

#include <ctype.h>

该函数的作用是判断一个字符是否是十进制数字(‘0’~‘9’)，若是，返回1，否则，返回0.例如：

#include <iostream>
#include <ctype.h>
using namespace std;

int main()
{
    char str1,str2;
    cin>>str1>>str2;
    cout<<isdigit(str1)<<endl;
    cout<<isdigit(str2)<<endl;
    return 0;
}

运行结果为：
在这里插入图片描述
（3）atof()函数
该函数属于stdlib.h标准库，若要调用该函数，需要在头文件中写入：

#include <stdlib.h>

其作用是将一个由十进制数字和小数点组成的字符串转换成浮点数，例如：

#include <iostream>
#include <cstring>
#include <stdlib.h>
using namespace std;

int main()
{
    char str[10];
    strcpy(str,"2.1415");
    cout<<1.0+atof(str)<<endl;
    return 0;
}

运行程序会输出3.1415

以下是用顺序栈实现的完整代码：

#include <iostream>
#include <cstring>
#include <stdlib.h>
#include <ctype.h>
#define MaxSize 20    //操作数序列可能的最大长度
#define INFINITY 1e9  //代表正无穷
using namespace std;
typedef double ElementType;
/*定义枚举类型，其中的三个元素分别对应运算数、运算符、字符串结尾*/
enum Type{num,opr,end};
/*定义顺序栈结构类型*/
struct Stack
{
    ElementType data[MaxSize];
    int top;
};

int main()
{
    ElementType PostfixExpr(char *Expr);

    char Ex[MaxSize];
    cin.getline(Ex,MaxSize);  //读入带空格的字符串
    ElementType result;
    char *Expr=Ex;

    result=PostfixExpr(Expr);
    if(result<INFINITY)
        cout<<result<<endl;
    else
        cout<<"表达式错误"<<endl;

    return 0;
}

/*初始化顺序栈*/
void InitStack(Stack *s)
{
    s->top=-1;
}

/*入栈：将元素x读入栈顶元素*/
void Push(Stack *s,ElementType x)
{
    if(s->top==MaxSize-1)
        cout<<"栈已满";
    else{
        s->data[++(s->top)]=x;
    }
}

/*退栈：弹出栈顶元素*/
ElementType Pop(Stack *s)
{
    if(s->top==-1){
        cout<<"栈空";
        return 0;
    }
    else{
        return(s->data[(s->top)--]);
    }
}

/*从后缀表达式中读入一个对象（运算数或运算符），并将其保存、返回。
GetOp()函数的三个形参参数：
1.char *Expr 是指向后缀表达式(一个字符数组)的字符指针；
2.int *index 是指示后缀表达式(字符数组)下标的整型指针；
3.char *str 是指向保存所读对象(运算数或运算符)的字符指针。
函数的返回值是一个枚举类型
*/
Type GetOp(char *Expr,int *index,char *str)
{
    int i=0;

    while((str[i]=Expr[(*index)++])==' '); //跳过后缀表达式前的空格
    while(str[i]!=' ' && str[i]!='\0'){
        str[++i]=Expr[(*index)++];  //将后缀表达式中的运算数或运算符存入str[]数组中
    }
    if(str[i]=='\0')
        (*index)--;  //如果读到后缀表达式的结尾，使下标停在结束符处
    str[i]='\0';   //写入结束标志

    if(i==0)                 //判断是否读到后缀表达式的结束
        return end;
    else if(isdigit(str[0])) //判断str[]中存入的是否为运算数
        return num;
    else                    //判断str中是否存的运算符
        return opr;
}

/*调用GetOp()函数读入的后缀表达式，并求值*/
ElementType PostfixExpr(char *Expr)
{
    Stack sta,*S;
    S=&sta;
    Type T;
    ElementType Op1,Op2;
    char str[MaxSize];
    int index=0;

    InitStack(S);
    Op1=Op2=0;
    /*当未读到结束标识符时*/
    while((T=GetOp(Expr,&index,str))!=end){
        if(T==num)  //如果读到运算数，存入栈顶
            Push(S,atof(str));

        else{      //如果读到运算符，从栈中弹出最上面两个元素进行运算
            if(S->top!=-1)
                Op2=Pop(S);
            else
                Op2=INFINITY; //标记异常
            if(S->top!=-1)
                Op1=Pop(S);
            else
                Op2=INFINITY;
            switch(str[0]){
                case '+':Push(S,Op1+Op2);break;
                case '-':Push(S,Op1-Op2);break;
                case '*':Push(S,Op1*Op2);break;
                case '/':{
                    if(Op2!=0.0)
                        Push(S,Op1/Op2);
                    else{
                        cout<<"错误：分母除法为0"<<endl;
                    }
                    break;
                }
                default:cout<<"未知运算符"<<str[0]<<endl;Op2=INFINITY;break;
            }
            if(Op2>=INFINITY)
                break;    //若标记异常，退出while()循环
        }

    }
    if(Op2<INFINITY)  //若读数过程无异常
        if(S->top!=-1)
            Op2=Pop(S);
        else
            Op2=INFINITY;
    delete S;
    return(Op2);
}

以下是用链栈实现的完整代码：

#include <iostream>
#include <cstring>
#include <stdlib.h>
#include <ctype.h>
#define MaxSize 20    //操作数序列可能的最大长度
#define INFINITY 1e9  //代表正无穷
using namespace std;
typedef double ElementType;
/*定义枚举类型，其中的三个元素分别对应运算数、运算符、字符串结尾*/
enum Type{num,opr,end};
/*定义链栈结构类型*/
typedef struct SNode
{
    ElementType data;
    SNode *next;
}Stack;

int main()
{
    ElementType PostfixExpr(char *Expr);

    char Ex[MaxSize];
    cin.getline(Ex,MaxSize);  //读入带空格的字符串
    ElementType result;
    char *Expr=Ex;

    result=PostfixExpr(Expr);
    if(result<INFINITY)
        cout<<result<<endl;
    else
        cout<<"表达式错误"<<endl;

    return 0;
}

/*初始化链栈*/
void InitStack(Stack *s)
{
    s->next=NULL;
}

/*入栈：将元素x读入栈顶元素*/
void Push(Stack *s,ElementType x)
{
    Stack *p;
    p=new Stack;
    p->data=x;
    p->next=s->next;
    s->next=p;
}

/*退栈：弹出栈顶元素*/
ElementType Pop(Stack *s)
{
    Stack *p;
    ElementType x;
    if(s->next==NULL){
        cout<<"栈空";
        return 0;
    }
    else{
        p=s->next;
        x=p->data;
        s->next=p->next;
        delete p;
        return(x);
    }
}

/*从后缀表达式中读入一个对象（运算数或运算符），并将其保存、返回。
GetOp()函数的三个形参参数：
1.char *Expr 是指向后缀表达式(一个字符数组)的字符指针；
2.int *index 是指示后缀表达式(字符数组)下标的整型指针；
3.char *str 是指向保存所读对象(运算数或运算符)的字符指针。
函数的返回值是一个枚举类型
*/
Type GetOp(char *Expr,int *index,char *str)
{
    int i=0;

    while((str[i]=Expr[(*index)++])==' '); //跳过后缀表达式前的空格
    while(str[i]!=' ' && str[i]!='\0'){
        str[++i]=Expr[(*index)++];  //将后缀表达式中的运算数或运算符存入str[]数组中
    }
    if(str[i]=='\0')
        (*index)--;  //如果读到后缀表达式的结尾，使下标停在结束符处
    str[i]='\0';   //写入结束标志

    if(i==0)                 //判断是否读到后缀表达式的结束
        return end;
    else if(isdigit(str[0])) //判断str[]中存入的是否为运算数
        return num;
    else                    //判断str中是否存的运算符
        return opr;
}

/*调用GetOp()函数读入的后缀表达式，并求值*/
ElementType PostfixExpr(char *Expr)
{
    Stack sta,*S;
    S=&sta;
    Type T;
    ElementType Op1,Op2;
    char str[MaxSize];
    int index=0;

    InitStack(S);
    Op1=Op2=0;
    /*当未读到结束标识符时*/
    while((T=GetOp(Expr,&index,str))!=end){
        if(T==num)  //如果读到运算数，存入栈顶
            Push(S,atof(str));

        else{      //如果读到运算符，从栈中弹出最上面两个元素进行运算
            if(S->next!=NULL)
                Op2=Pop(S);
            else
                Op2=INFINITY; //标记异常
            if(S->next!=NULL)
                Op1=Pop(S);
            else
                Op2=INFINITY;
            switch(str[0]){
                case '+':Push(S,Op1+Op2);break;
                case '-':Push(S,Op1-Op2);break;
                case '*':Push(S,Op1*Op2);break;
                case '/':{
                    if(Op2!=0.0)
                        Push(S,Op1/Op2);
                    else{
                        cout<<"错误：分母除法为0"<<endl;
                    }
                    break;
                }
                default:cout<<"未知运算符"<<str[0]<<endl;Op2=INFINITY;break;
            }
            if(Op2>=INFINITY)
                break;    //若标记异常，退出while()循环
        }

    }
    if(Op2<INFINITY)  //若读数过程无异常
        if(S->next!=NULL)
            Op2=Pop(S);
        else
            Op2=INFINITY;
    delete S;
    return(Op2);
}
MilkLeong
关注
C++ 后缀表达式求值
HybridCOW_HORSE的博客
04-26 9272
📋 个人简介 🎉大家好，我是3月份新人榜排名第三的 ༺Blog༒Hacker༻ 💬支持我：点赞👍+收藏⭐️+留言📝 🌺格言：༺永做优质༒programmer༻ 📣后缀表达式求值 【问题描述】 读入一个后缀表达式（字符串），只含有0-9组成的运算数及 加（+）、减（−）、乘（∗）、除（/，整除）四种运算符，以及空格。 每个运算数之间用一个空格隔开，不需要判断给你的表达式是否合法。以’#'作为结束标志。 保证中间的运算过程不会爆INT 【输入格式】 一行字符，如【题目描述】。 【输出格式】 一个整数，表示表达式
C++实现后缀表达式求值
Jimmy Huang's Blog
06-07 1617
算法代码 C++程序 不使用头文件 使用头文件 运行结果
后缀表达式求值-C++实现
TLJava^v^的博客
04-20 7500
一、思路 给出一个后缀表达式（以字符串数组的形式，每一项要么是一个操作数字符串，要么是一个运算符），计算过程中要将操作数从string形式转换为int形式，在计算表达式运算结果时，需要设置一个栈 num 保存操作数，计算步骤如下： 1）若当前项是操作数，则将该操作数压入num栈中； 2）若当前项是运算符，则从操作数栈中出栈两个操作数（栈顶的数作为第二个操作数，次栈顶的数作为第一个操作数），计算两个操作数进行运算的结果，然后将结果压入操作数栈num中。
后缀表达式求值（基于C++）
bestkasscn的博客
05-12 3727
后缀表达式求值 基本思想： ​ 建立一个操作数栈S。然后从左到右读表达式，如果读到操作数就将它压入栈S中，如果读到n元运算符(即需要参数个数为n的运算符)则取出由栈顶向下的n项操作数进行运算，再将运算的结果代替原栈顶的n项压入栈中。重复上面过程，如果后缀表达式读完且栈中只剩一个操作数，则该数就是运算结果；如果后缀表达式读完但是栈中操作数多于一个，则后缀表达式错误；如果栈中操作数只剩一个，但是后缀表达式还未读完且当前运算符为双元操作符，则后缀表达式同样错误。 测试样例：5 2 + 3 * 代码实现： //后缀
C++ 数据结构 栈 中缀表达式转后缀表达式并求值
weixin_59629651的博客
10-10 3594
C++数据结构课堂，中缀表达式转后缀表达式
c++使用堆栈实现中缀表达式转后缀表达式
11-13
c++使用堆栈实现中缀表达式转后缀表达式
C++实现中缀表达式转后缀表达式并求值
wanna_wsl的博客
08-03 4606
中缀表达式（中缀记法） 中缀表达式是一种通用的算术或逻辑公式表示方法，操作符以中缀形式处于操作数的中间。中缀表达式是人们常用的算术表示方法。虽然人的大脑很容易理解与分析中缀表达式，但对计算机来说中缀表达式却是很复杂的，因此计算表达式的值时，通常需要先将中缀表达式转换为前缀或后缀表达式，然后再进行求值。对计算机来说，计算前缀或后缀表达式的值非常简单。例如：(3 + 4) × 5 - 6 就是中缀表
考研数据结构2 | 使用 C++ 实现顺序栈 | 栈的基本应用之计算后缀表达式
希望每天都能进步一点点
10-09 1032
本篇回顾了栈的概念，介绍了三种不同的表达式以及特点，阐述了后缀表达式计算的方法，并使用顺序栈实现后缀表达式。
【c++】后缀表达式求值（详解）
m0_74044018的博客
09-12 5717
后缀表达式的介绍和详细代码实现，计算逆波兰表达式的结果，用C++实现
后缀表达式求值
08-22
后缀表达式求值,练习堆栈，算法。大家需要可以参考下
后缀表达式求值cpp
06-06
#include "stdio.h" #include "stdlib.h" typedef char DataType;//声明自定义数据类型 typedef struct snode//声明栈结点
计算后缀表达式的值[C/C++]
Tanhauser的博客
11-02 642
学校老师出的pta题目
C++后缀表达式求值源码
给你一个大么么的博客
04-15 1890
#include&lt;iostream&gt; #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; using namespace std; template &lt;class T&gt; struct Node {     T data;     Node&lt;T&gt; *next; }; template&lt;class T&gt; cl...
后缀表达式计算
花无名
04-10 2223
利用栈完成后缀表达式的计算(1043) Time limit(ms): 1000 Memory limit(kb): 10000 Submission: 384 Accepted: 235 Accepted 后缀表达式不包含括号，运算符放在两个运算对象的后面，所有的计算按运算符出现的顺序，严格从左向右进行（不再考虑
C++ 使用栈求解中缀、后缀表达式的值
y6123236的专栏
10-13 2670
表达式求值对于有知识积累的你而言，可以通过认知，按运算符的优先级进行先后运算。但对计算机而言，表达式仅是一串普通的信息而已，需要通过编码的方式告诉计算机运算法则，这个过程中栈起到了至关重要的作用。表达式由2操作数。运算符。在一个复杂的表达式中，操作数和运算符可以有多个，运算符之间存在优先级，且不同运算符所需要的操作数的数量也有差异。这时，表达式的计算过程就变得较复杂。为了简化问题，本文只限于讨论基于常量操作数和双目运算符的表达式。在计算机中，表达式的描述可以有以下3。
后缀表达式的运算（C语言）
mirrorboat的博客
01-22 353
#include<stdio.h> #include<stack> using namespace std; stack<int> s; //考虑多位数字 空格分割 int main() { char str[100]={"2 3 * 5 4 * + 9 -"}; int i=0; int flag=0,temp=0; for(;str[i];i++) { if(str[i]=='+'||str[i]=='-'||str[i]=='*'||str[i]=.
后缀表达式的计算（c++代码实现）
m0_62466789的博客
03-10 1662
使用栈对数据进行存放 读取到操作符时取栈顶的两位数进行计算 其中数据包括负数，小数等 （P.S.自己写的代码，不具有参考性，但是能跑就行，求轻喷） #include<iostream> using namespace std; template<class T> class Stack { private: int top; T *elements; int MaxSize; public: Stack(int Maxsize); ~Stack(){
C++ 中缀转后缀表达式并求值
08-25 472
//中缀转后缀 #include<iostream> #include<stack> using namespace std; int prio(char x){ if(x=='*'||x=='/') return 2; if(x=='+'||x=='-') return 1; if(x=='(') retu...
【C++】红黑树的封装——同时实现map和set
最新发布
Mesar的博客
09-27 640
学习map和set，深入了解底层，通过模拟实现，学习高效数据结构与容器的关系，也帮助我们更好了解和使用容器
C++实现栈表达式求值：加减乘除运算
"该资源提供了一个使用C++实现的基于栈的表达式求值程序，支持加、减、乘、除运算。程序基于数据结构原理，可以处理带有括号的数学表达式，并以'#'作为输入表达式的结束标志。用户可以进行简单的修改以适应更复杂的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值