[数据结构] 表达式求值（转化为后缀表达式再求值或直接求值）

最新推荐文章于 2024-08-24 13:34:07 发布
最新推荐文章于 2024-08-24 13:34:07 发布
阅读量5.2k 收藏 19
点赞数 2
分类专栏： 数据结构 积少成多 ACM常用算法及模板整理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sr_19930829/article/details/50809712
版权

两种情况：

1. 根据输入的算数表达式，如（56-20) /(4+2)， 先转化为后缀表达式（逆波兰式）56#20#-4#2#+/  因为输入的数字有多位数的（56）,所以数之间用#隔开，然后根据后缀表达式求值。

2.根据输入的算数表达式，直接进行求值。


对于情况1：

转化为后缀表达式时用到了一个符号栈，把后缀表达式存放到数组postExp中，根据后缀表达式求值时用到了一个运算数栈，运算完后，栈顶即为所求。

完整代码如下：

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <stack>
#include <queue>
using namespace std;

const int maxOp = 7;//符号的总数

struct  Pri      //设定运算符优先级
{
    char ch;     //运算符
    int pri;     //优先级
}lpri[] = {{'=', 0}, {'(', 1}, {'*', 5}, {'/', 5}, {'+', 3}, {'-', 3}, {')', 6}},
 rpri[] = {{'=', 0}, {'(', 6}, {'*', 4}, {'/', 4}, {'+', 2}, {'-', 2}, {')', 1}};

int LeftPri(char op)//求左运算符op的优先级
{
    for(int i = 0; i < maxOp; ++ i)
        if(lpri[i].ch == op)
            return lpri[i].pri;
}

int RightPri(char op)//求右运算符op的优先级
{
    for(int i = 0; i < maxOp; ++ i)
        if(rpri[i].ch == op)
            return rpri[i].pri;
}

bool IsOp(char ch)//判断符号ch是否为运算符
{
    if(ch == '(' || ch == ')' || ch == '+' || ch == '-' || ch == '*' || ch == '/')
        return true;
    return false;
}

int Precede(char op1, char op2) //op1和op2运算符优先级的比较结果
{
    int lPri = LeftPri(op1);
    int rPri = RightPri(op2);
    if(lPri == rPri)
        return 0;
    else if(lPri < rPri)
        return -1;
    else
        return 1;
}

void TransToPostExp(char* exp, char postExp[]) //将算数表达式exp转换成后缀表达式
{
    stack<char>opStack;//运算符栈
    opStack.push('=');// =入栈，其优先级最低
    int i = 0;//后缀表达式字符指针
    while(*exp != '\0')
    {
        if(!IsOp(*exp)) //如果不是运算符
        {
            while(*exp >= '0' && *exp <= '9')//是数字
            {
                postExp[i ++] = *exp;
                exp ++;
            }
            postExp[i ++] = '#'; //用'#'表示一个数值串的结束，比如456#
        }
        else
        {
            int cmpPri = Precede(opStack.top(), *exp);
            if(cmpPri == 0) //左右运算符优先级相等，也就是()这种情况
            {
                opStack.pop();// '('退栈
                exp ++;
            }
            else if(cmpPri == -1) //栈顶运算符优先级低
            {
                opStack.push(*exp);//入栈,符号栈栈顶始终是优先级最高的
                exp ++;
            }
            else  //栈顶运算符优先级高
            {
                while(Precede(opStack.top(), *exp) == 1)//不断退栈
                {
                    postExp[i ++] = opStack.top();
                    opStack.pop();
                }
                //opStack.push(*exp);
                // exp ++;  一定要注意！不能这样写，因为有可能当前字符是')'
            }
        }
    }
    while(opStack.top() != '=')//exp扫描完毕，退栈到' = '为止
    {
        postExp[i ++] = opStack.top();
        opStack.pop();
    }
    postExp[i] = '\0';//postExp表达式添加结束标识
}

void GetTwoFromStack(stack<double>& numStack, double& a, double& b)//从运算数栈中获取两个数，栈顶和次栈顶
{
    a = numStack.top();
    numStack.pop();
    b = numStack.top();
    numStack.pop();
}

float CalFromPostExp(char* postExp)//计算后缀表达式的值
{
    stack<double> numStack;//运算数栈
    double a, b;
    while(*postExp != '\0')
    {
        switch(*postExp)
        {
        case '#':
            break;
        case '+':
            GetTwoFromStack(numStack, a, b);//获取运算数栈的两个数
            numStack.push(b + a);//进行运算，再压入运算数中
            break;
        case '-':
            GetTwoFromStack(numStack, a, b);
            numStack.push(b - a);
            break;
        case '*':
            GetTwoFromStack(numStack, a, b);
            numStack.push(b * a);
            break;
        case '/':
            GetTwoFromStack(numStack, a, b);
            if(a != 0)
                numStack.push(b / a);
            else
            {
                cout << "除0错误! " <<endl;
                exit(0);
            }
            break;
        default: //处理数字字符
            int n = 0;
            while(*postExp >= '0' && *postExp <= '9')
            {
                n = n * 10 + (*postExp - '0');
                postExp ++;
            }
            numStack.push(n);
            break;
        }
        postExp ++; //继续处理字符
    }
    return numStack.top();
}

char exp[50];
char postExp[50];

int main()
{
    while(cin >> exp)
    {
        cout << "中缀表达式为: " << exp <<endl;
        TransToPostExp(exp, postExp);//将算数表达式转化为后缀表达式,比如输入(56-20)/(4+2) ,输出 56#20#-4#2#+/
        cout << "后缀表达式为: " << postExp <<endl;
        cout << "表达式的值为: " <<CalFromPostExp(postExp) << endl << endl;
    }
    return 0;
}

及其容易出现错误的地方为void TransToPostExp(char* exp, char postExp[]) //将算数表达式exp转换成后缀表达式   这个函数中： 

else  //栈顶运算符优先级高
            {
                while(Precede(opStack.top(), *exp) == 1)//不断退栈
                {
                    postExp[i ++] = opStack.top();
                    opStack.pop();
                }
                //opStack.push(*exp);
                // exp ++;  一定要注意！不能这样写，因为有可能当前字符是')'
            }

一定要注意如果当前字符时')'时，它的右优先级是最低的，因为除了'('外的其它符号 + - * / 遇到它都得退出符号栈

不要把')'加入到符号栈中，opStack.push(*exp)；

也不要直接忽略')'而继续扫描下一个字符，因为此时栈顶可能时'('，需要进行下一轮的比较，把'('出栈， 所以不能写 exp ++.

也就是说 这里需要特别考虑 当前字符是 ')'的情况


对于情况2：

用到了两个栈，符号栈和运算数栈，对输入的运算数表达式边扫描边求值。

完整代码（来来回回改了N多遍,  支持 ((((3+2))))这种情况) :

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <stack>
#include <queue>
using namespace std;

const int maxOp = 7;//符号的总数

struct  Pri      //设定运算符优先级
{
    char ch;     //运算符
    int pri;     //优先级
}lpri[] = {{'=', 0}, {'(', 1}, {'*', 5}, {'/', 5}, {'+', 3}, {'-', 3}, {')', 6}},
 rpri[] = {{'=', 0}, {'(', 6}, {'*', 4}, {'/', 4}, {'+', 2}, {'-', 2}, {')', 1}};

int LeftPri(char op)//求左运算符op的优先级
{
    for(int i = 0; i < maxOp; ++ i)
        if(lpri[i].ch == op)
            return lpri[i].pri;
}

int RightPri(char op)//求右运算符op的优先级
{
    for(int i = 0; i < maxOp; ++ i)
        if(rpri[i].ch == op)
            return rpri[i].pri;
}

bool IsOp(char ch)//判断符号ch是否为运算符
{
    if(ch == '(' || ch == ')' || ch == '+' || ch == '-' || ch == '*' || ch == '/')
        return true;
    return false;
}

int Precede(char op1, char op2) //op1和op2运算符优先级的比较结果
{
    int lPri = LeftPri(op1);
    int rPri = RightPri(op2);
    if(lPri == rPri)
        return 0;
    else if(lPri < rPri)
        return -1;
    else
        return 1;
}


void GetTwoFromStack(stack<double>& numStack, double& a, double& b)//从运算数栈中获取两个数，栈顶和次栈顶
{
    a = numStack.top();
    numStack.pop();
    b = numStack.top();
    numStack.pop();
}



double CalFromNumStack(stack<char>& opStack, stack<double>& numStack)
//从符号栈提取栈顶符号，利用运算数栈的栈顶和次栈顶进行计算，并把结果压入运算数栈中
{
    double a, b;
    char op = opStack.top();//运算符提取
    opStack.pop();//退栈
    GetTwoFromStack(numStack, a, b);//a,b为栈顶和次栈顶
    switch(op)
    {
    case '+':
        numStack.push(b + a);
        break;
    case '-':
        numStack.push(b - a);
        break;
    case '*':
        numStack.push(b * a);
        break;
    case '/':
        numStack.push((b / a));
        break;
    }//switch
}

float CalFromExp(char* exp)
{
    stack<char> opStack;//符号栈
    opStack.push('=');//'='优先级最低
    stack<double> numStack;//运算数栈
    while(*exp != '\0')
    {
        if(!IsOp(*exp)) //如果不是运算符
        {
            int n = 0;//提取数字
            while(*exp >= '0' && *exp <= '9')
            {
                n = n * 10 + (*exp - '0');
                exp ++;
            }
            numStack.push(n);//把提取出来的数压入运算数栈
        }
        else
        {
            int cmpPri = Precede(opStack.top(), *exp);
            if(cmpPri == 0)  // ')'遇到栈顶'('
            {
                opStack.pop();
                exp ++;
            }

            else if(cmpPri == -1)// 栈顶运算符优先级小
            {
                opStack.push(*exp);
                exp ++;
            }
            else  //栈顶运算符优先级大
            {
                while(Precede(opStack.top(), *exp) == 1)
                {
                    CalFromNumStack(opStack,numStack);
                }//while
            }
           // exp ++;//扫描下一个字符
        }//当前字符是运算符
    }

    while(opStack.top() != '=')//千万不能忘了这个！！
    {
        CalFromNumStack(opStack,numStack);
    }
    return numStack.top();
}
char exp[50];
char postExp[50];

int main()
{
    while(cin >> exp)
    {
        cout << "中缀表达式为: " << exp <<endl;
        //TransToPostExp(exp, postExp);//将算数表达式转化为后缀表达式,比如输入(56-20)/(4+2) ,输出 56#20#-4#2#+/
       // cout << "后缀表达式为: " << postExp <<endl;
        cout << "表达式的值为: " <<CalFromExp(exp) << endl << endl;
    }
    return 0;
}

及其容易出现错误的地方和情况1一样。


将原表达式转换成后缀表达式——表达式求值问题
04-18
严蔚敏数据结构中表达式求值问题，将原表达式转换成后缀表达式，C语言描述，VC环境下编译通过，运行正确。
C语言数据结构算法-简单表达式求值(支持计算负数及小数)
01-08
在这个项目中，我们关注的是一个特定的算法——中缀表达式转化为后缀表达式（也称逆波兰表示法）以及后缀表达式的求值，特别地，这个实现已经扩展了对负数和小数的支持。 中缀表达式是我们常见的数学表达式形式，如...
表达式求值（中缀表达式转为后缀表达式）--数据结构与算法--栈
Liu1_1_的博客
10-19 380
本文利用数据结构中的栈实现了，表达式求值，以及后缀表达式和中缀表达式的转换，希望对读者有所帮助。
P1175 表达式转换
最新发布
Niubilityone的博客
08-24 288
后缀表达式
数据结构——表达式求值（中缀表达式转换后缀表达式）
m0_57534474的博客
10-25 675
首先，我们先来看下用堆栈来实现中缀表达式转换为后缀表达式的思路： 1.依次读取中缀表达式各项元素； 2.读取到操作数的时候，直接输出到后缀表达式的队列中 3. ...
表达式求值及转化为前缀、后缀表达式
2301_76523872的博客
06-29 404
那么将这个概念抽象化，形如A O B 的表达式 ， O为一个操作符(二元) ， A和B为一个子表达式，且A是一个形如A O B表达式的根结点，将该表达式转化为二叉树形式得到表达式二叉树即可轻松地求出其前缀表达式和后缀表达式，仅需要前序遍历和后序遍历该树即可。表达式求值问题在程序设计中经常遇见，通过本课程设计，使学生掌握表达式的不同表示形式及相应的求值方法，加深对栈的基本原理和方法的理解和应用，培养学生运用语言编程及调试的能力，运用数据结构解决简单的实际问题的能力，为后续计算机专业课程的学习打下坚实的基础。
数据结构实验之栈二：一般算术表达式转换成后缀式
zhang_di233的专栏
07-20 1296
 题目描述 对于一个基于二元运算符的算术表达式，转换为对应的后缀式，并输出之。 输入 输入一个算术表达式，以‘#’字符作为结束标志。 输出 输出该表达式转换所得到的后缀式。 示例输入 a*b+(c-d/e)*f# 示例输出 ab*cde/-f*+ #include #include #include #include #include
数据结构实验，输入一个表达式，利用表达式转化为后缀后，求其表达式值
06-09
### 数据结构实验：将输入的表达式转换为后缀表达式并计算其值 #### 实验背景与目标 本实验的主要目的是让学生理解并实现一种重要的数据结构应用——栈（Stack），并通过栈的操作来完成表达式的转换及计算。具体...
哈工大数据结构作业-算数表达式求值
11-29
在哈工大的数据结构课程中，学生被分配了一项作业，任务是实现一个算数表达式求值的程序。这个程序不仅需要处理基本的算数运算，如加法、减法、乘法和除法，还要扩展到处理小数计算以及涉及变量的计算。这个项目旨在...
中缀，后缀表达式求值以及相互转化
11-12
数据结构课程实验，实现了终端输入输出的中缀表达式求值，后缀表达式求值，中缀表达式转化后缀表达式，以及文件流的中缀表达式求值，后缀表达式求值，中缀表达式转化后缀表达式，可操作整数，小数，浮点数，实现运算...
自定义栈中缀表达式转换为后缀表达式并求值
05-20
### 自定义栈中缀表达式转换为后缀表达式并求值 #### 需求分析与背景 在计算机科学领域，将一个中缀表达式转换为后缀表达式是解决算术表达式求值问题的一种常用方法。通过这种方式可以避免括号带来的优先级问题，...
原表达式转换成后缀表达式——表达式求值问题
04-18
数据结构中表达式求值问题，将原表达式转换成后缀表达式，C语言描述，VC环境下编译通过，运行正确。
表达式求值---（中缀表达式转后缀表达式及后缀表达式求值结合）
Hunter_Kevin的博客
12-04 1139
题目： 利用栈编写表达式求值程序：输入含有“ + ”、“ - ”、“ * ”、“ / ”四则运算的表达式，其中负数要用（0 - 正数）表示，并以 = 结束。要求输出表达式的值。 输入格式 第一行：一个算术表达式 输出格式 第一行：算术表达式的值 输入样例 3 * (9 - 7) = 输出样例 6 一、解题思路： ①. 注意栈元素为整型类型。由于表达式的运算符号为字符类型，但依然能够以ASCII码形式储存在栈中，故栈元素可以不用定义为字符类型，而定义为整型类型数据即可，方便从后缀表达式中将字符类型.
算术表达式转成后缀表达式（逆波兰式）并求值
初级搬砖工的博客
03-14 6637
算术表达式转成后缀表达式（逆波兰式)并求值
计算表达式-将中缀表达式转换为后缀表达式后计算
qq_62795094的博客
09-24 335
后缀表达式运算
数据结构实验之栈与队列二：一般算术表达式转换成后缀式
小乔美哒哒
10-12 234
Problem Description 对于一个基于二元运算符的算术表达式，转换为对应的后缀式，并输出之。 Input 输入一个算术表达式，以‘#’字符作为结束标志。 Output 输出该表达式转换所得到的后缀式。 Sample Input a*b+(c-d/e)*f# Sample Output ab*cde/-f*+ Hint #include &lt;stdio....
常规表达式转化为后缀表达式再求值
moluchase的专栏
04-08 606
/* 常规表达式转化为后缀表达式再求值  */ #include char op[20],postexp[50]; int r=-1,front=0,st[20]; void push1(int m) { r++; st[r]=m; } int pop1() { return st[r--]; } /*求值，这个函数遇到很多问题，比如那个 那个case语句中n和
算术表达式转后缀表达式求值
kkkkde的博客
10-06 8765
数据结构c语言算术表达式求值（转化为后缀表达式的方法）（双栈：符号栈和数据栈）
数据结构 表达式求值
09-29
表达式求值是指将一个数学表达式计算出结果的过程。将中缀表达式转化为后缀表达式是求解表达式求值的一种常用方法。后缀表达式也叫逆波兰表达式，它的特点是运算符位于操作数之后。通过扫描中缀表达式，按照一定的规则将其转换为后缀表达式，然后再根据后缀表达式进行计算，即可得到表达式的结果。 关于表达式求值，有几个关键的步骤： 1. 创建一个栈用于存储运算符和中间结果。 2. 从左到右扫描中缀表达式的每个字符。 3. 如果遇到操作数，则将其输出，如果遇到运算符，则将其压入栈中。 4. 如果遇到左括号，则将其压入栈中。 5. 如果遇到右括号，则持续弹出栈顶运算符并输出，直到遇到左括号为止。 6. 如果遇到优先级比栈顶运算符高的运算符，则将其压入栈中。 7. 如果遇到优先级比栈顶运算符低的运算符，则持续弹出栈顶运算符并输出，直到栈顶运算符优先级低于当前运算符或栈为空为止。 8. 重复步骤3到步骤7，直到扫描完整个中缀表达式。 9. 将栈中剩余的运算符依次弹出并输出。 对于后缀表达式的计算，可以利用栈来完成。从左到右扫描后缀表达式的每个字符，如果遇到操作数，则将其压入栈中，如果遇到运算符，则从栈中弹出两个操作数进行运算，并将结果压入栈中。最终，栈中的唯一元素即为表达式的结果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值