逆波兰表达式
逆波兰表达式

问题背景表达式求值是程序设计语言编译中的一个最基本的问题.因为任何程序设计语言都必须具有表达式求值的功能,同时表达式的计算应用也相当广泛,比如电力调度系统中的计算遥测、车站票务系统中的票价类型计算公式等。
通常,我们所说的表达式是由运算符、操作数、界限符所组成。
而算术表达式中最常见的表示法形式有中缀、前缀和后缀表示法。
中缀表示法是书写表达式的常见方式,而前缀和后缀表示法主要用于计算机科学领域。
1、中缀表达式———将运算符放在两操作数的中间。
在运算中存在运算符的优先权与结合性的问题。
例如运算:a*b+(c-d/e)*f 时,编译器即自左向右逐一检查,当检查到第一个运算符“*”时还无法知道是否执行;待检查到第二个运算符“ + ”时,因为知道“*”的优先级别高于“ + ”时,才知道执行“a*b”;当继续检查到“ ( ”时,可知道先执行括号以内部分等。
2、前缀表达式———将运算符放在两操作数的前面。
这种表示法经常用于计算机科学,特别是编译器设计方面。
为纪念其发明家—Jan Lukasiewicz,这种表示法也称波兰表示法。
3、后缀表达式———将运算符放在两操作数的后面。
后缀表达式也称逆波兰表达式,因其使表达式求值变得轻松,所以被普遍使用。
前缀和后缀表示法有三项公共特征:(1)操作数的顺序与等价的中缀表达式中操作数的顺序一致(2)不需要括号(3)操作符的优先级不相关题目描述读入一个后缀表达式,利用堆栈来计算该表达式的值,同时要效验后缀表达式是否正确,并输出相关信息一、需求分析1、输入的形式和输入值得范围:输入一后缀表达式,相邻项之间以空格隔开,以#为结束标志,操作数为实数,操作符为+ - * / ;2、输出的形式:如果表达式正确则输出表达式的计算结果,若不正确则输出错误提示3、程序的功能:从键盘读入一后缀表达式(操作数是实数),如果表达式正确输出表达式的计算结果,如果表达式错误,则输出错误提示。
4、测试数据:样例1:输入: 2.5 3 * 5 - 3 + #(正确的输入)输出:************************运算结果是5.5样例2:输入: 2.5 3 * 3 - + #(错误的输入)输出:表达式错误!************************并弹出错误提示:二、概要设计1、抽象数据类型:为实现以上功能,根据题目要求,采用链式栈来存储表达式的操作数,数据成员top用来指向链式栈第一个节点(栈顶),变量element用来存储栈顶节点的值,变量size用来记录当前栈的大小链式栈的基本操作:Lstack(int size = 0,sNode* top=NULL);//栈的构造函数void Insert(double a);//向栈中插入一元素double pop();//取出栈顶元素int GetSize(){ return size;}//返回当时栈的大小计算表达式的函数:void Compute();2、算法的基本思想:(1)成员Insert(double a )首先建立一新的节点并修改新产生的节点的next域指向栈顶,然后设置top指向新的链表节点,并把size的值加1(2)成员pop()中如果栈的大小大于1,则返回栈顶元素,变量tos 用来记录栈顶元素,p用来指向当前的栈顶节点,把top指向当前栈顶的下一个节点,然后释放p指向的节点,同时size减1,返回tos;如果栈的大小小于1,则抛出一整型异常(3)函数Compute()中建立了链式栈s,并定义double 类型的变量x,y,字符类型的变量a。
逆波兰表达式

逆波兰表达式逆波兰表达式表达式⼀般由操作数(Operand)、运算符(Operator)组成,例如算术表达式中,通常把运算符放在两个操作数的中间,这称为中缀表达式(Infix Expression),如A+B。
波兰数学家Jan Lukasiewicz提出了另⼀种数学表⽰法,它有两种表⽰形式:把运算符写在操作数之前,称为波兰表达式(Polish Expression)或前缀表达式(Prefix Expression),如+AB;把运算符写在操作数之后,称为逆波兰表达式(Reverse Polish Expression)或后缀表达式(Suffix Expression),如AB+;其中,逆波兰表达式在编译技术中有着普遍的应⽤。
算法:⼀、将中缀表达式转换成后缀表达式算法:1、从左⾄右扫描⼀中缀表达式。
2、若读取的是操作数,则判断该操作数的类型,并将该操作数存⼊操作数堆栈3、若读取的是运算符(1) 该运算符为左括号"(",则直接存⼊运算符堆栈。
(2) 该运算符为右括号")",则输出运算符堆栈中的运算符到操作数堆栈,直到遇到左括号为⽌。
(3) 该运算符为⾮括号运算符:(a) 若运算符堆栈栈顶的运算符为括号,则直接存⼊运算符堆栈。
(b) 若⽐运算符堆栈栈顶的运算符优先级⾼或相等,则直接存⼊运算符堆栈。
(c) 若⽐运算符堆栈栈顶的运算符优先级低,则输出栈顶运算符到操作数堆栈,并将当前运算符压⼊运算符堆栈。
4、当表达式读取完成后运算符堆栈中尚有运算符时,则依序取出运算符到操作数堆栈,直到运算符堆栈为空。
⼆、逆波兰表达式求值算法:1、循环扫描语法单元的项⽬。
2、如果扫描的项⽬是操作数,则将其压⼊操作数堆栈,并扫描下⼀个项⽬。
3、如果扫描的项⽬是⼀个⼆元运算符,则对栈的顶上两个操作数执⾏该运算。
4、如果扫描的项⽬是⼀个⼀元运算符,则对栈的最顶上操作数执⾏该运算。
5、将运算结果重新压⼊堆栈。
java逆波兰表达式求值

java逆波兰表达式求值一、什么是逆波兰表达式逆波兰表达式(Reverse Polish notation,简称RPN)是一种将运算符放在操作数后面的表达式表示方法。
例如,中缀表达式“2+3”可以写成逆波兰表达式“2 3 +”。
二、为什么要使用逆波兰表达式使用逆波兰表达式可以避免使用括号来区分优先级,使得计算机在计算时更加高效。
三、如何将中缀表达式转换为逆波兰表达式1. 创建一个栈S用于存储运算符。
2. 从左到右扫描中缀表达式的每个元素:(1)如果元素是数字,则直接输出。
(2)如果元素是运算符,则判断:a. 如果栈S为空或栈顶元素为左括号“(”,则将该运算符压入栈S中;b. 否则,比较该运算符与栈顶运算符的优先级:i. 如果该运算符优先级高于栈顶运算符,则将该运算符压入栈S中;ii. 否则,将栈顶元素弹出并输出,然后继续比较该运算符与新的栈顶元素的优先级。
(3)如果元素是左括号“(”,则将其压入栈S中。
(4)如果元素是右括号“)”,则依次弹出栈顶元素并输出,直到遇到左括号“(”,将左括号弹出但不输出。
3. 如果中缀表达式扫描完毕,则依次弹出栈中所有运算符并输出。
四、如何使用逆波兰表达式求值1. 创建一个栈S用于存储操作数。
2. 从左到右扫描逆波兰表达式的每个元素:(1)如果元素为数字,则将其压入栈S中。
(2)如果元素为运算符,则弹出栈顶的两个操作数进行运算,并将结果压入栈S中。
3. 如果逆波兰表达式扫描完毕,则栈S中只剩下一个数字,即为该表达式的计算结果。
五、Java实现逆波兰表达式求值可以通过使用Java的Stack类来实现上述算法。
具体步骤如下:1. 将中缀表达式转换为逆波兰表达式,得到一个字符串数组tokens。
2. 创建一个Stack<Integer>对象stack用于存储操作数。
3. 从左到右扫描tokens数组的每个元素:(1)如果元素为数字,则将其转换为整数并压入stack中。
逆波兰表达式还原

逆波兰表达式还原一、逆波兰表达式的概念与作用逆波兰表达式(Reverse Polish Notation,简称RPN)是一种用于计算复杂数学表达式的记法。
在这种记法中,运算符放在操作数的后面,从而使得运算顺序与普通数学表达式相反。
逆波兰表达式的优势在于,它便于使用栈进行计算,同时避免了优先级和结合性的问题。
二、还原逆波兰表达式的基本方法1.括号匹配法:这种方法主要是通过匹配括号来确定运算顺序,从而还原出原始表达式。
但是这种方法需要额外的空间来存储括号信息,且效率较低。
2.栈数据结构法:这种方法利用栈的特性,将输入的表达式依次压入栈中。
当遇到运算符时,根据运算符的优先级和结合性来决定是否弹出栈顶的运算符进行计算。
如此循环,直至栈为空。
3.递归法:这种方法将表达式分为三种类型:运算符、操作数和空。
对于每一种类型的节点,分别编写对应的还原函数。
在递归过程中,根据节点的类型和上下文信息,还原出原始表达式。
三、不同编程语言中的实现与应用1.Python:可以使用栈数据结构实现逆波兰表达式的还原,如使用ListNode类构建表达式树,并利用栈来存储节点。
2.JavaScript:可以使用递归方法实现逆波兰表达式的还原,如使用数组存储表达式各部分,并根据节点类型进行相应的处理。
3.C++:可以借鉴栈数据结构法的思想,使用类或结构体来模拟栈,实现逆波兰表达式的还原。
四、示例与解析以下以一个简单的逆波兰表达式为例,演示如何进行还原:原始表达式:`a + b * c`逆波兰表达式:`+ * a b c`根据逆波兰表达式,我们可以先计算乘法,再计算加法。
假设a、b、c分别为2、3、4,则还原过程如下:1.依次将a、+、b、*、c压入栈:2 3 4 + *2.遇到乘法运算符,弹出栈顶的两个数进行计算:2 * 3 = 6,将结果6留在栈顶,表达式变为:6 4 +3.遇到加法运算符,弹出栈顶的两个数进行计算:6 + 4 = 10,得到最终结果10。
逆波兰表达式 if -回复

逆波兰表达式if -回复什么是逆波兰表达式?逆波兰表达式(Reverse Polish Notation,简称RPN)是一种将计算操作符放在操作数之后的数学表达式表示方法。
它与传统的中缀表达式(操作符在操作数中间)不同,在逆波兰表达式中,运算符永远跟在它的操作数后面。
逆波兰表达式起源于20世纪50年代,由澳大利亚哲学家、计算机科学家Charles Leonard Hamblin首次提出。
逆波兰表达式在计算机科学领域被广泛应用于编译器设计和计算器实现等方面。
逆波兰表达式的特点是操作符位于操作数的后面,这样的排列顺序可以消除使用括号来确定运算的先后顺序,使得逆波兰表达式可以以一种简洁而连贯的方式表示数学表达式。
同时,计算逆波兰表达式也比传统的中缀表达式更加高效,可以通过堆栈来实现逆波兰表达式的计算。
逆波兰表达式的基本原则是通过将操作符放在操作数之后来表示计算顺序,这样每次遇到一个操作符时,就可以将其前面的两个操作数作相应的计算,从而逐步进行表达式的求值。
下面将详细介绍逆波兰表达式的计算过程。
逆波兰表达式的计算过程:步骤1:从左到右遍历逆波兰表达式的每个元素;步骤2:如果当前元素是一个操作数(即数字),则将其压入堆栈;步骤3:如果当前元素是一个操作符,则从堆栈中弹出前两个操作数进行相应的计算,并将计算结果压入堆栈;步骤4:重复步骤2和步骤3,直到遍历完整个逆波兰表达式;步骤5:最后,堆栈中仅剩下一个元素,即为最终的计算结果。
逆波兰表达式的一个例子是:3 4 + 5 *在这个例子中,我们可以按照上述计算过程依次进行计算:步骤1:遍历3,将其压入堆栈;步骤2:遍历4,将其压入堆栈;步骤3:遍历+,从堆栈中弹出4和3,并计算3 + 4的结果7,将结果7压入堆栈;步骤4:遍历5,将其压入堆栈;步骤5:遍历*,从堆栈中弹出5和7,并计算5 * 7的结果35,将结果35压入堆栈;步骤6:最后,堆栈中仅剩下一个元素35,即为最终的计算结果。
波兰表达式和逆波兰表达式

波兰表达式和逆波兰表达式波兰表达式和逆波兰表达式是两种不同的数学表达式表示方法,它们都是数学领域中常用的算术表达式形式。
这两种表达式形式在计算机科学领域中也非常重要,尤其在编译器设计和计算机科学理论中有着广泛的运用。
一、波兰表达式(Polish Notation)波兰表达式是由波兰数学家扬·奥尔加罗夫斯基(JanŁukasiewicz)在1920年引入的一种新型数学表达式方式。
波兰表达式的特点是将操作符写在其对应的操作数之前,这样的表达方式也被称为前缀表达式。
例如,将传统的中缀表达式"3 + 4"转换成波兰表达式的形式,变为"+ 3 4"。
在波兰表达式中,操作符出现在对应的操作数之前。
波兰表达式的特点使得它具有一些优势。
首先,波兰表达式没有括号,因为操作符的位置明确,减少了解析表达式的复杂性;其次,波兰表达式可以直接用栈进行计算,简化了表达式的求值过程。
二、逆波兰表达式(Reverse Polish Notation)逆波兰表达式是由澳大利亚科学家查利斯·哈米脱(Charles Hamblin)在1957年引入的一种表达式形式。
逆波兰表达式的特点是将操作符写在对应的操作数之后,这种表达方式也被称为后缀表达式。
例如,将传统的中缀表达式"3 + 4"转换成逆波兰表达式的形式,变为"3 4 +"。
在逆波兰表达式中,操作符出现在对应的操作数之后。
逆波兰表达式相较于波兰表达式也有一些优势。
首先,逆波兰表达式同样没有括号,减少了解析表达式的复杂性;其次,逆波兰表达式的计算过程更加直观,可以通过简单的遍历来按照操作符进行计算。
三、波兰表达式和逆波兰表达式的应用波兰表达式和逆波兰表达式在计算机科学领域中有广泛的应用。
1.编译器设计:波兰表达式和逆波兰表达式是编译器设计中的重要概念。
编译器在解析和计算表达式时,可以通过将中缀表达式转换为波兰表达式或逆波兰表达式来简化计算过程。
逆波兰表达式 python
逆波兰表达式 Python逆波兰表达式简介什么是逆波兰表达式?逆波兰表达式,也称为后缀表达式,是一种将运算符写在操作数之后的数学表达式表示方法。
逆波兰表达式的特点是没有括号,并且运算符的优先级通过运算符的位置来决定。
逆波兰表达式的优点逆波兰表达式的主要优点是可以消除运算符优先级的问题,使得计算过程更加简单和直观。
逆波兰表达式还可以通过栈来实现计算,这样可以避免使用递归或者复杂的算法。
逆波兰表达式的应用场景逆波兰表达式在计算器、编译器、公式计算等领域有广泛的应用。
由于逆波兰表达式的计算过程简单,可以通过栈来实现,因此在计算机中的实现也相对容易。
逆波兰表达式的实现逆波兰表达式的计算步骤1.从左到右遍历表达式的每个元素;2.如果当前元素是操作数,则将其压入栈中;3.如果当前元素是运算符,则从栈中弹出两个操作数,进行运算,并将结果压入栈中;4.重复步骤2和步骤3,直到遍历完所有元素;5.栈中最后剩下的元素即为计算结果。
逆波兰表达式的实现步骤1.创建一个空栈用于存储操作数;2.从左到右遍历表达式的每个元素;3.如果当前元素是操作数,则将其压入栈中;4.如果当前元素是运算符,则从栈中弹出两个操作数,进行运算,并将结果压入栈中;5.重复步骤3和步骤4,直到遍历完所有元素;6.栈中最后剩下的元素即为计算结果。
逆波兰表达式的 Python 实现class Solution:def evalRPN(self, tokens: List[str]) -> int:stack = []for token in tokens:if token in "+-*/":num2 = stack.pop()num1 = stack.pop()if token == "+":stack.append(num1 + num2)elif token == "-":stack.append(num1 - num2)elif token == "*":stack.append(num1 * num2)elif token == "/":stack.append(int(num1 / num2))else:stack.append(int(token))return stack[0]逆波兰表达式的应用逆波兰表达式在计算器中的应用计算器通常会使用逆波兰表达式来处理用户输入的数学表达式。
逆波兰表达式
基本思路:
扫描后缀算术表达式字符串,每次从字符串中读取一个字符, 读到空格不做任何处理,若读到运算符,则表明它的两个操 作数已经在栈中,否则读到的字符必为数字,应把它转换为 一个正整数存入一个变量中,然后把计算或转换得到的正整 数(即该变量的值)压入栈中,依次扫描每个字符并进行上述 处理,直到遇到结束符,表明后缀表达式计算完成,最终结 果保存在栈中,并且栈中只有这一个值。
function rpn() Begin read(ch) while ( ch <> '\n') do begin case (ch) of case ’+’ : r ← pop()+pop() push(r) case ’-’ : r ← pop() r ← pop()-r push(r) case ’*’ : r ← pop()*pop() push(r) case ’/’ : r ← pop() r ← pop()/r push(r) end
前缀表达式的递归定义,就像正常表达式可以递归定义一样。
c (常量) rpn rpn rpn - rpn rpn * rpn rpn / rpn rpn
可以考虑用递归函数来求解。
function rpn() begin read(ch) case ch of case ’+’ case ’-’ case ’*’ case ’/’ case ’ ’ default end end
Hale Waihona Puke : : : : : :return return return return return return
rpn() + rpn() rpn() * rpn() / rpn() ch-’0’
逆波兰表达式
逆波兰表达式逆波兰表达式⼜叫做后缀表达式。
在通常的表达式中,⼆元运算符总是置于与之相关的两个运算对象之间,这种表⽰法也称为中缀表⽰。
波兰逻辑学家J.Lukasiewicz于1929年提出了另⼀种表⽰表达式的⽅法,按此⽅法,每⼀运算符都置于其运算对象之后,故称为后缀表⽰。
a+b ---> a,b,+a+(b-c) ---> a,b,c,-,+a+(b-c)*d ---> a,b,c,-,d,*,+a+d*(b-c)--->a,d,b,c,-,*,+1、将⼀个中序表达式转化成为逆波兰表达式构造两个栈S1,S2,S1⽤来存放表达式,S2⽤来暂时存放运算符,最后完成后,该栈是清空的。
(1)如果遇到的是数字,直接进栈S1(2)如果遇到的是左括号,进栈S2(3)如果遇到的是右括号,将S2中的运算符全部出栈压⼊S1中,注意括号不压⼊(4)如果遇到的运算符1.如果此时栈S2为空,则直接将运算符加⼊到栈S2中;2.如果此时栈S2不为空,当前运算符的优先级⼤于等于栈顶运算符的优先级,那么直接⼊栈S2;3.如果此时栈S2不为空,当前运算符的优先级⼩于栈顶运算符的优先级,则将栈顶运算符⼀直出栈压⼊到栈S1中,直到栈为空或者遇到⼀个运算符的优先级⼩于等于当前遍历的运算符的优先级,然后将该运算符压⼊到栈S2中。
(5)遍历完整个中序表达式之后,如果栈S2中仍然存在运算符,那么将这些运算符依次出栈压⼊到栈S1中,直到栈为空。
2、利⽤逆波兰表达式求值维护⼀个结果栈S3,该栈最后存放的是表达式的值。
从左⾄右的遍历栈S1(1)如果遇到的是数字,直接将数字压⼊到S3中(2)如果遇到的是单⽬运算符,取S3栈顶的⼀个元素进⾏运算之后,将结果压⼊到栈S3中(3)如果遇到的是双⽬运算符,取S3栈顶的两个元素,⾸先出栈的在左,后出栈的在右进⾏双⽬运算符的计算,将结果压⼊到S3中遍历完整个栈S1,最后S3中的值就是逆波兰表达式的值。
逆波兰表达式还原
逆波兰表达式还原【原创实用版】目录1.逆波兰表达式的定义与特点2.逆波兰表达式的转换方法3.逆波兰表达式在计算机科学中的应用正文【逆波兰表达式的定义与特点】逆波兰表达式(Reverse Polish Notation,简称 RPN),是一种用于表示算术表达式的方式,其特点是将运算对象放在运算符之前,即“后缀表达式”。
例如,表达式“3 + 5”的逆波兰表达式为“+ 3 5”。
这种表达式的主要优点是避免了运算符的优先级问题,使得计算过程更加简单。
【逆波兰表达式的转换方法】将中缀表达式转换为逆波兰表达式的方法比较简单。
首先,我们需要遍历整个表达式,从左到右识别每个运算符。
当遇到运算符时,将该运算符之后的所有数字(即运算对象)按照运算符的优先级依次添加到栈中。
然后,继续遍历表达式,直至遍历完整个表达式。
最后,将栈中的运算对象依次弹出,按照弹出的顺序拼接成逆波兰表达式。
例如,将中缀表达式“3 + 5”转换为逆波兰表达式:1.遇到“+”,将“5”入栈;2.遇到“3”,将“3”入栈;3.遍历完整个表达式,弹出栈中的“3”和“5”,得到逆波兰表达式“+ 3 5”。
【逆波兰表达式在计算机科学中的应用】逆波兰表达式在计算机科学中有广泛的应用,尤其在计算表达式的值和编译器设计等领域。
1.计算表达式的值:由于逆波兰表达式的计算顺序明确,不存在优先级问题,因此可以简化计算过程。
特别是对于复杂的表达式,逆波兰表达式可以降低计算的复杂度。
2.编译器设计:在编译器中,逆波兰表达式可以用于表示程序中的算术表达式,方便编译器进行语法分析和代码生成。
通过将中缀表达式转换为逆波兰表达式,可以简化编译器的设计,提高编译效率。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
(3)另外我们需要通过if语句来判断表达式的正误。
②程序基本流程
首先假设此表达式正确从字符串第一个开始扫描,遇到运算数就先转化成为数值然后压入堆栈中,
如遇到运算符则弹出堆栈上面的两个元素(根据后缀表达式,我们知道运算符前的两个为两个操作数),并进行对应的运算,将得到的结果压入栈中,直到最后一个字符为止。
假设表达式不正确的情况,(1)是输入的数字格式不正确,例如输入数字为小数时,直接从.开始(2)表达式最后栈中还有两个或更多数(3)表达式栈中只有一个数时,仍然碰到了运算符,则我们输出“输入的逆波兰表达式错误”。
五、实验代码:
CString CMFCDlg::fun(CString s)
{
int leng=s.GetLength();
}
六:结果分析
当输入2 3 * 5 / #时候:
输出结果为:1.2000
经过多次使用发现结果没有问题。
七、实验心得
这一次实验更加的了解了栈的原理和MFC的使用,在做逆波兰表达式时候遇到一个问题,将输入框中的字符串拆封出其数字和操作符再进行计算,之后还是通过判断其成分,遇到数字就入栈,操作符就进行数字。
后缀表示法有三个特征:
(1) 操作数的顺序与等价的中缀表达式中操作数的顺序一致
(2) 不需要括号
(3) 操作符的优先级不相关
二、基本要求:
(1) 从键盘中输入一个后缀表达式 , 该表示包括加减乘除等操作符 , 以及正整数作为操作数等。
(2)用堆栈来实现逆波兰表达式
(3)判断该表达式是否正确。
三、输入输出格式
result=stack[top-2]+stack[top-1];
top--;
stack[top-1]=result;
}
else if(s[i]=='-')
{
if(top=1)
{
return C="输入的逆波兰表达式有错误";
}
else
result=stack[top-2]-stack[top-1];
top--;
stack[top-1]=result;
}
else if(s[i]=='*')
{
if(top=1)
{
return C="输入的逆波兰表达式有错误";
}
else
result=stack[top-2]*stack[top-1];
top--;
stack[top-1]=result;
}
else if(s[i]=='/')
CString C;
float *stack,result;
stack=new float[leng];
int i=0,j=0;
int top=0;
while(s[i]!='#')
{
if(s[i]!='+'&&s[i]!='-'&&s[i]!='*'&&s[i]!='/'&&s[i]!='#39;)
输入输出格式
输入:
在字符界面上输入一个后缀表达式 , 其中两相邻操作数之间利用空格隔开 。 以“ #” 表示结束。
输出:
如果该后缀表达式正确,那么在字符界面上输出其结果,计算结果小数点后面
保留两位有效数字,如果不正确,请在字符界面上输出表达式错误提示。
四、具体设计过程
1算法思想:
(1)首先因为计算后缀表达式有先进后出,后进先出的规律,因而符合堆栈的思想。因而使用堆栈实现。
HUNANUNIVERSITY
数据结构实验报告
题 目逆波兰表达式求值
学生姓名王家威
学生学号201308070217
专业班级智能科学与技术1302
指导老师朱宁波
一、问题描述:
读入一个后缀表达式 ,利用堆栈来计算该表达式的值,同时要效验后缀表达式是否正确
注释:后缀表达式 — 将运算符放在两操作数的后面。后缀表达式也称逆波兰表达式 , 因其使表达式求值变得轻松,所以被普遍使用。
}
if(top==1)
{
char p[20];
sprintf(p,"%.4f",stack[0]);
return C=p;
}
else
return C="输入的逆波兰表达式有错误";
}
void CMFCDlg::OnOK()
{
UpdateData(TRUE);
m_p=fun(m_s);
UpdateData(FALSE);
xs=xs+d*(s[i]-'0');
i++;
}
}
}
stack[top]=zs+xs;
top++;
}
}
else if(s[i]=='.')
{
return C="输入的逆波兰表达式有错误";
}
else if(s[i]=='+')
{
if(top=1)
{
return C="输入的逆波兰表达式有错误";
}
else
{
float zs=0,xs=0;
while(s[i]!=' ')
{
j=i;
while(s[i]!='.'&&s[i]!=' ')
{
zs=zs*pow(10.0,i-j)+(s[i]-'0');
i++;
}
j=i;
if(s[i]=='.')
{
i++;
while(s[i]!=' ')
{
double d=pow(10.0,j-i);
{
if(top=1)
{
return C="输入的逆波兰表达式错误";
}
else if(stack[top-1]='0')
{
return C="输入中出现了除数为零";
}
else
result=stack[top-2]/stack[top-1];
top--;
stack[top-1]=result;
}
i++;