表达式求值基本构架

最新推荐文章于 2021-10-12 16:51:46 发布
最新推荐文章于 2021-10-12 16:51:46 发布
阅读量284 收藏
点赞数
分类专栏： acm学习资料

转了一个大神的博客，如果大神看见了，勿怪，我想自己纪念一下，只是敬仰！大神的博客

两种情况：

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一样。



风吹过的烟花
关注
专栏目录
【专家独推】全网最全Matlab常用函数（包括按首字母进行分类）
左手の明天的博客
03-30 3万+
目录 1、求组合数 2、求阶乘 3、求全排列 4、求指数 5、求行列式 6、求矩阵的转置 7、求向量的指数 8、求自然对数 9、求矩阵的逆矩阵 10、多项式的乘法运算 11、多项式除法 12、求一个向量的最大值 13、求矩阵的最大值和最小值 14、求和与求积 15、平均值、标准方差 16、相关系数 17、排序 18、多项式的求导 19、多项式的求值 20、常用的基本数学函数 21、常用的三角函数 22、适用于向量的常用函数 23、MATLAB的永久常数 24、
数据库系统原理例题之——SQL 与关系数据库基本操作
最新发布
run__ning的博客
12-26 1465
解析： 因为是要查询加入协会编号为“XH4” 的学生的学号 、姓名 、所在系 ，所以可以利用子查询的方法 实现 ，先在关系表入会中查询协会编号是XH4 的学号 ，然后根据学号对关系表学生进行查询 ，即可查询出 加入协会编号为XH4 的学生的学号、姓名、所在系。因为要查询学生的学号 ，姓名和所在系 ，所以投影。（ 2 ）视图的内容是由存储在数据库中进行查询操作的 SQL 语句来定义的，它的列数据与行数据均来自于定 义视图的查询所引用的真实表 ，并且这些数据是在引用视图时动态生成的。
表达式求值
11-08
背景： 我们的教材中已经介绍了表达式求值的算法，现在我们将该算法的功能进行扩展，要求可以处理的运算符包括：+、-、*、/、%（整数取余）、^（乘方）、（、）。 要求： 采用算符优先算法，计算的中间结果只保留整数。 输入： 第一行为整数N。表示下面有N个表达式 从第二行起的后面N行为N个由整数构成的表达式 输出： 共N行，每行为相应表达式的计算结果。 如果判断出表达式有错误，则输出：error. 如果在计算过程中出现除数为0的情况，则输出：Divide 0. 特殊情况说明： 在表达式中，如果操作数出现负数（例如-8），则要特别注意。例如： 10加-8表示为：10+-8。 10减-8表示为：10--8。
NYOJ,305,表达式求值
ieayoio
08-08 1433
表达式求值 时间限制：3000 ms  |  内存限制：65535 KB 难度：3 描述 Dr.Kong设计的机器人卡多掌握了加减法运算以后，最近又学会了一些简单的函数求值，比如，它知道函数min(20,23)的值是20 ，add(10,98) 的值是108等等。经过训练，Dr.Kong设计的机器人卡多甚至会计算一种嵌套的更复杂的表达式。 假设表达式可以简单定义为: 1. 一
有关表达式求值的一些思考
lovetheme的专栏
12-27 851
 最近在实现一个表达式的evaluator，具体来说，就是对表达式求值，算出最终的结果。目前的这个版本的evaluator只针对常量表达式，对变量表达式则不去处理。因为对于变量表达式，是无法在编译期间求出其最终结果的，只有等到执行阶段才具备算出结果的全部条件。Evaluator的实现机理并不太复杂，简单来说，就是一个递归下降的求值过程。如果把表达式的语法结构表征为一
表达式求值思路
学习印记 Learning imprint
09-25 2689
对一个表达式进行求值，需要把
用栈数据结构对算数表达式求值的思想
bc_33的博客
10-12 2096
问题描述 表达式求值是程序设计语言编译中的一个基本问题，是栈应用的一个典型例子。对于一个简单的算数表达式，假如它的操作数是整型常数，运算符有加减乘除四种运算符，界限符有左右括号、表达式起始符和表达式结束符（#）。那么，它应遵循算数四则运算的规则是：从左到右，先括号内，后括号外，先乘除后加减。 算法分析 要对一个算数表达式求值，首先要了解算符（运算符和界限符）间的优先关系，即算数表达式的计算顺序，从而决定如何对表达式进行操作。对算数表达式进行扫描，任意两个相继...
.Net构架下的加密编程
03-04
加密编程在.NET构架下是一项重要的安全技术，用于保护数据的隐私性和完整性。本文主要探讨了使用密钥散列值方法进行数据加密的过程，并且强调了.NET Framework中的System.Security.Cryptography框架在加密操作中的...
struts构架及标签库
03-11
视图部分则利用Struts标签库来呈现数据，这些标签使得开发者能够更方便地将后台数据绑定到页面元素，避免了过多的Java脚本和JSP EL表达式。 Struts标签库包括一系列预定义的HTML和逻辑标签，它们提供了丰富的功能，...
python爬虫之一_基本架构
IMchg的博客
09-06 531
本文内容来源于慕课网爬虫视频 一 python爬虫基本架构 1.1 基本架构 一个完整的爬虫程序包含以下以下四个部件：调度器、URL管理器、网页下载器、网页解析器。 调度器： 调用其他组件，并控制目标数据输出； URL管理器： 保存待爬取、已爬取URL，要防止爬取重复的URL； 网页下载器： 根据URL下载HTML页面或多媒体内容，对于动态页面要考虑执行js； 网页解析器： 解析HTML页面中的文本信息，获取目标数据和新的URL链接； 1.2 基本流程 二 各组件功能 2.1 调度器 调用URL.
算术表达式求值演示
12-25
大家快点下载吧 有你们需要的资源 课程设计
表达式求值（包括多位数、小数、负数）
04-08
将一个表达式先转化为后缀式，然后利用后缀式求表达式的值，可计算多位数、小数、负数。
数据结构表达式求值，c语言版，能计算多位数
08-01
数据结构表达式求值，c语言版，能计算多位数,下载后可以直接运行，注释明确
用数据结构“栈”的思想对表达式求值
heimei620的专栏
05-16 405
表达式求值（中缀表达式-＞后缀表达式）
myjess’s blog
05-13 1546
题目：在一个表达式中，只有“(”，“)”，“0-9”，“+”，“-”，“*”，“/”，“^”，请求出表达式的值。(“/”用整数除法)。 将中缀表达式转化成后缀表达式，一边转化，一边计算。 基本思路： 读取完字符串之后，扫描一遍，扫描一遍后，运算也同时结束，过程中将中缀表达式转化成后缀表达式，一边转化，一边计算。 1.如果碰到了数字，开始往数字栈放数字(考虑多位数情况) 2.如果碰到了 “(” 直接入符号栈 3.如果碰到了运算符，如果其优先级大于符号栈顶元素优先级，入栈； 否则，先计算符号栈顶元素和数字栈顶两
C++ Primer 第四章—— 表达式 思维导图
weixin_46698891的博客
05-09 299
C++ Primer 第四章—— 表达式 思维导图 前言：该博文的定位是，您已经对C语言的基础知识和C++ Primer该书或C++知识有了基本了解。而在阅读C++ Primer（第五版）之后，感觉知识未成体系化，或阅读前该思维导图可以给出本章的大致知识框架和重点内容，在阅读时将帮助您对本章知识有大致了解和目标。 ...
【数据结构】 之 表达式求值
10-12 4373
如要下载编译器，请看我的之前博客 笔者现大三，这篇博文及后面的几篇博文都是对大二所做的题目一些总结，哈哈，感觉自己那时候学的还可以，希望自己这点笔记能对你们有点帮助吧，加油！！！其实数据结构也没传说中的那么难，并且以后在我们面试的时候，数据结构可是面试官的法宝，对吧，咱们不能输在起跑线线上，好了，废话不多说，现在让我们来学习表达式求值。我先把老师给我们出的题目给大家看看吧，不知道我们是不是一样的
ADAMS教程：定义函数表达式与机械系统分析
此外，教程还涵盖了机械系统的基本概念，包括机械系统的构成、参考机架、坐标系和自由度的计算方法。" 在ADAMS中定义函数表达式是一项关键任务，它允许用户根据需要定制计算模型中的各种物理量。例如，函数f2定义了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值