语法制导把表达式翻译成逆波兰式

表达式转换成逆波兰式
早在上世纪20年代，逆波兰式（Reverse Polish Notation，RPN）就出现了。

它的目的是提高计算机程序执行速度，以减少计算机
程序员使用时间，同时提高计算机程序操作的准确性。

因此，在程序
设计中它得到了广泛应用，成为一种基础的数学表达符号。

逆波兰表达式（RPN）指的是把一个表达式按照一定的规则转换
成一种逆波兰的表达式。

这种表达式的每个元素都是单个操作数或操
作符号，操作符放在操作数之前，各操作符号和操作数按照一定次序
跟随在一起。

RPN有许多优势，如解释性强、空间利用率高、更易于扩展和容
错率高等，且不会因为把操作符和操作数放置次序反而影响计算结果。

例如，将一个表达式 sus=(a+b)*c转化成它的逆波兰式即：a b + c * sus =
RPN的算法更加容易理解，它使用的操作数及操作符只有当前字
符的操作数及操作符，而不需要像结构化算法那样维护进入和离开栈
的字符（操作数和操作符）的相关信息。

RPN算法也在某些场合得到广泛的应用，尤其是在使用的机器无
法处理复杂程序时，如小型计算机或一些移动设备。

同时，RPN也是一种被广泛使用的量化计算方法，可以节省时间和精力，提高数学计算
过程的准确性。

总之，逆波兰表达式是一种有效的、普遍应用并且在不同场合用
途十分重要的广泛运用于数学计算中的技术。

它可以消除操作符在表
达式中的优先级差异，将一个复杂的表达式简化为另一个同意义的，
更简洁的表达式，从而提高计算的准确性和速度。

把表达式转换为逆波兰表达式的方法把表达式转换为逆波兰表达式的方法什么是逆波兰表达式？逆波兰表达式（Reverse Polish Notation，简称RPN）是一种数学表达式的表示方法，其中运算符位于操作数的后面，而不是中间。

例如，将中缀表达式 3 + 4转换为逆波兰表达式的结果是 3 4 +。

为什么要使用逆波兰表达式？逆波兰表达式具有以下优点：1.不需要括号：逆波兰表达式由于运算符在操作数的后面，所以不需要括号来定义运算次序。

2.方便计算机计算：逆波兰表达式可以直接由计算机进行计算，减少了计算机解析表达式的复杂性。

3.避免二义性：逆波兰表达式的书写方式清晰明确，没有二义性。

方法一：使用栈实现转换1.初始化一个空栈和一个空列表用于存储转换后的逆波兰表达式。

2.从左到右扫描表达式。

3.如果遇到操作数（数字），则直接添加到逆波兰表达式列表中。

4.如果遇到运算符，按照以下规则处理：–如果栈为空或栈顶为左括号（或无运算符优先级低于当前运算符），则直接将运算符入栈。

–如果栈顶为运算符，并且其优先级大于等于当前运算符，将栈顶运算符出栈并添加到逆波兰表达式列表中，直到栈为空或栈顶为左括号（或无运算符优先级低于当前运算符）为止，然后将当前运算符入栈。

–如果当前运算符为右括号，则将栈顶运算符依次出栈并添加到逆波兰表达式列表中，直到遇到左括号为止。

5.扫描完成后，将栈中剩余的运算符依次出栈并添加到逆波兰表达式列表中。

6.逆波兰表达式列表即为转换后的结果。

方法二：使用递归实现转换1.定义一个递归函数，传入表达式和当前处理位置。

2.判断当前位置处的字符：–如果是数字，则直接返回该数字。

–如果是运算符，则递归调用函数获取左右两个操作数，并根据运算符将其组合成一个逆波兰表达式返回。

–如果是左括号，则继续向后处理直到找到对应的右括号。

3.递归函数返回结果即为转换后的逆波兰表达式。

方法三：使用中缀转后缀的方法1.定义两个栈，一个用于临时存储运算符，一个用于存储转换后的逆波兰表达式。

逆波兰表达式逆波兰表达式表达式⼀般由操作数(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、将运算结果重新压⼊堆栈。

实验6 逆波兰式的翻译和计算一、实验目的通过实验加深对语法指导翻译原理的理解，掌握算符优先分析的方法，将语法分析所识别的表达式变换成中间代码的翻译方法。

二、实验内容设计一个表示能把普通表达式（中缀式）翻译成后缀式，并计算出结果的程序。

三、实验要求1、给出文法如下：G[E]E->T|E+T;T->F|T*F;F->i(E);对应的转化为逆波兰式的语义动作如下： E-> E (1)op E (2) {E.CODE:= E (1).CODE||E (2).CODE||op} E->(E (1)) { E.CODE := E (1).CODE}E->id { E.CODE := id}2、利用实验5中的算符优先分析算法，结合上面给出的语义动作实现逆波兰式的构造；3、利用栈，计算生成的逆波兰式，步骤如下：1） 中缀表达式，从文本文件读入，每一行存放一个表达式，为了降低难度，表达式采用常数表达式；2） 利用结合语法制导翻译的算符优先分析，构造逆波兰式；3） 利用栈计算出后缀式的结果，并输出；四、实验环境PC 微机DOS 操作系统或 Windows 操作系统Turbo C 程序集成环境或 Visual C++ 程序集成环境五、实验步骤1、了解语法制导翻译的方法，学习后缀式构造的语义动作；2、结合实验5的算符优先程序，设计程序构造后缀式；3、利用栈，编程实现后缀式的计算；4、测试程序运行效果：从文本文件中读表达式，在屏幕上输出，检查输出结果。

六、测试数据输入数据：编辑一个文本文文件expression.txt，在文件中输入如下内容：正确结果：（1）1+2;输出：1,2,+ 3（2）(1+2)*3;输出：1,2,+,3,* 9（3）(10+20)*30+(50+60*70)输出：10,20,+30,*50,60,70,*,+,+ 5150七、实验报告要求实验报告应包括以下几个部分：1、构造逆波兰式的语义动作；2、结合算符优先分析构造逆波兰式的算法和过程；3、语法制导翻译的运行方法；4、程序的测试结果和问题；5、实验总结。

if (x>='0'&&x<='9')j=0;else{
j=1;
while(j<6&&x!=vt[j]) j++;
if(j>=6){
printf("error\n");
return 0;
}}
if(action[y][j]==NULL){
printf("error\n");
return 0;
}
strcpy(copy,action[y][j]);
}
}while(1);
}
int compvalue(){ /*计算后缀表达式的值*/
int stack[10]; /*作为栈使用*/
int s=0,top=0; /*t为ex下标，top为stack下标*/
while(d[s]!='#'){
switch(d[s]){
case '+':
stack[top-2]=stack[top-2]+stack[top-1];
printf("请输入表达式\n");
do{
scanf("%c",&c1);
c[top3]=c1;
top3=top3+1;
}while(c1!='#');
i=judge( );
if(i==1)printf("acc\n");
d[t++]='#';
for( i=0;i<t;i++)
printf("%c",d[i]);

中缀表达式变后缀表达式、后缀表达式（逆波兰）求值（python版本）定义：中缀表达式：在通常的表达式中，⼆元运算符总是置于与之相关的两个运算对象之间，这种表⽰法也称为中缀表达式后缀表达式：⼜叫逆波兰表达式，不包含括号，放在两个运算对象的后⾯，所有的计算按运算符出现的顺序，严格从左向右进⾏（不再考虑运算符的优先规则，如：(2 + 1) * 3 ，即2 1 + 3 *⼀个字符串表达式s = “9 + ( 3 - 1 ) * 3 + 10 / 2”）求值的过程分为两步(⼀) 将中缀表达式s变为后缀表达式s_after = "9 3 1 - 3 * + 10 2 / +",具体的规则如下：⾸先维护两个空栈，（stack_exp）存放逆波兰表达式，(stack_ops)暂存操作符，运算结束后stack_ops必为空循环遍历字符串(将表达式分为四种元素 1、数值; 2、操作符; 3、左括号; 4、右括号)，具体情况如下1、遇到数值，将该值⼊栈stack_exp2、遇到左括号，将左括号⼊栈stack_ops3、遇到右括号，将stack_ops中的操作符从栈顶依次出栈并⼊栈stack_exp，直到第⼀次遇到左括号终⽌操作（注意：该左括号出栈stack_ops但不⼊栈stack_exp）⾄此消除表达式中的⼀对括号4、遇到四则运算操作符号（+ - * /）4-1、如果stack_ops为空，操作符⼊栈stack_ops4-2、如果stack_ops不空，将stack_ops栈顶操作符与遍历到的操作符(op)⽐较：4-2-1：如果stack_ops栈顶操作符为左括或者op优先级⾼于栈顶操作符优先级， op⼊栈stack_ops，当前遍历结束4-2-2：如果op优先级⼩于或者等于stack_ops栈顶操作符， stack_ops栈顶操作符出栈并⼊栈stack_exp，重复4-1、 4-2直到op⼊栈stack_ops5、字符串遍历结束后如果stack_ops栈不为空，则依次将操作符出栈并⼊栈stack_exppython代码实现如下：ops_rule = {'+': 1,'-': 1,'*': 2,'/': 2}def middle_to_after(s):expression = []ops = []ss = s.split('')for item in ss:if item in ['+', '-', '*', '/']:while len(ops) >= 0:if len(ops) == 0:ops.append(item)breakop = ops.pop()if op == '('or ops_rule[item] > ops_rule[op]:ops.append(op)ops.append(item)breakelse:expression.append(op)elif item == '(':ops.append(item)elif item == ')':while len(ops) > 0:op = ops.pop()if op == '(':breakelse:expression.append(op)else:expression.append(item)while len(ops) > 0:expression.append(ops.pop())return expression(⼆) 将后缀表达式s_after = "9 3 1 - 3 * + 10 2 / +" 求值,具体的规则如下：初始化⼀个空栈stack_value，⽤于存放数值循环s_after1、如果遇到数字，⼊栈stack_value;2、如果遇到运算符，从stack_value中依次出栈两个数（先出栈的在右，后出栈的在左）连同遍历到的运算符组成⼆⽬运算，求值后将结果压栈stack_value3、继续遍历下⼀个元素，直到结束遍历完后stack_value中的结果便是表达式的值python代码实现如下：def expression_to_value(expression):stack_value = []for item in expression:if item in ['+', '-', '*', '/']:n2 = stack_value.pop()n1 = stack_value.pop()result = cal(n1, n2, item)stack_value.append(result)else:stack_value.append(int(item))return stack_value[0]def cal(n1, n2, op):if op == '+':return n1 + n2if op == '-':return n1 - n2if op == '*':return n1 * n2if op == '/':return n1 / n2if __name__ == '__main__':expression = middle_to_after('9 + ( 3 * ( 4 - 2 ) ) * 3 + 10 / 2')value = expression_to_value(expression)print value。

– 自底向上：
•
在构造分析树的结点的同时计算相关的属性（此时其子 结点的属性必然已经计算完毕）
– 自顶向下：
• 递 A调归用子的程其序他法过中程，（在对过应程于A子()的结最构后）计已算经A调的用属完性毕（）此时
a
22
在分析树上计算SDD
• 按照后序遍历的顺序计算属性值即可
postorder(N)
第五章 语法制导的翻译
赵建华 南京大学计算机系
2010年3月
a
1
介绍
• 使用上下文无关文法引导语言的翻译
– CFG的非终结符号代表了语言的某个构造 – 程序设计语言的构造由更小的构造组合而成 – 一个构造的语义可以由小构造的含义综合而来
• 比如：表达式x+y的类型由x、y的类型和运算符+决 定。
– 也可以从附近的构造继承而来
– 规则和产生式相关联
• 对于文法符号X和属性a，我们用X.a表示分 析树中的某个标号为X的结点的值。
• 一个分析树结点和它的分支对应于一个产 生式规则，而对应的语义规则确定了这些 结点上的属性的取值。
a
4
分析树和属性值(1)
• 假设我们需要知道一个表达式的类型，以及对 应代码将它的值存放在何处，我们就需要两个
{ for(从左边开始，对N的每个子结点C)
postorder(c); //递归调用返回时，各子结点的属性计算完毕 对N的各个属性求值；
} • 在LR分析过程中，我们实际上不需要构造分析树的
结点。
a
23
L属性的SDD
• 每个属性
– 要么是综合属性，
– 要规么则是只继能承使属用性，且产生式AX1X2…Xn中计算Xi.a的

i=0; zf=0; j=0; h=0; while(wfh[i]!='$') { ch1=wfh[i]; ch2=wfh[i+1]; if(ch1>='0' && ch1<='9') { if((ch2>='0'&& ch2<='9') || ch2=='.' || zf=1; else zf=0; } if(ch1=='.') { if(ch2>='0'&& ch2<='9'&& j<=1 ) zf=1;
ch2=='e'||ch2=='$' )
zf=1; elsh
zf=0; } if(ch1=='e'){ if(ch2>='0' && ch2<='9' && h<=1||ch2=='+'||ch2=='-')
zf=1; else zf=0; } if(ch1=='+' || ch1=='-'){
if(i==0) break; if(ch2>='0' && ch2<='9'||ch2=='$') zf=1; else zf=0; } if (zf==0) break; else i++; } if(zf==0) printf("Input number are error!\n"); else printf("Input number are right!\n"); }

1.◆3.21③假设表达式由单字母变量和双⽬四则运算算符构成。

试写⼀个算法，将⼀个通常书写形式且书写正确的表达式转换为逆波兰式。

实现下列函数：char *RPExpression(char *e);/* 返回表达式e的逆波兰式 */Stack是⼀个已实现的栈。

可使⽤的相关类型和函数：typedef char SElemType; // 栈Stack的元素类型Status InitStack(Stack &s);Status Push(Stack &s, SElemType e);Status Pop(Stack &s, SElemType &e);Status StackEmpty(Stack s);SElemType Top(Stack s);------------------------------------------------------------------------------------------------- 拿到题⽬，要做的第⼀件事情，就是搞懂题⽬究竟要我们做什么，很显然，题⽬中的关键字是“逆波兰式”，那么⾸先我们要搞懂这个概念。

所谓的逆波兰表⽰法（Reverse Polish notation，RPN，或逆波兰记法），是⼀种数学表达式⽅式，在逆波兰记法中，所有操作符置于操作数的后⾯，因此也被称为后缀表⽰法。

逆波兰记法不需要括号来标识操作符的优先级。

（摘⾃维基） 举个简单的例⼦，平常我们写的数学表达式a+b，就是⼀种中缀表达式，写成后缀表达式就是ab+。

再举⼀个复杂的例⼦，中缀表达式(a+b)*c-(a+b)/e的逆波兰式是ab+c*ab+e/-。

在弄清楚概念以及题⽬的要求之后，接下来就要编写算法了。

那么将⼀个表达式转换为逆波兰式的算法思想是什么呢？ (1)⾸先，需要分配2个栈，栈s1⽤于临时存储运算符（含⼀个结束符号），此运算符在栈内遵循越往栈顶优先级越⾼的原则；栈s2⽤于输⼊逆波兰式，为⽅便起见，栈s1需先放⼊⼀个优先级最低的运算符，在这⾥假定为'#'； (2)从中缀式的左端开始逐个读取字符x，逐序进⾏如下步骤： 1.若x是操作数，则分析出完整的运算数（在这⾥为⽅便，⽤字母代替数字），将x直接压⼊栈s2； 2.若x是运算符，则分情况讨论： 若x是'('，则直接压⼊栈s1； 若x是')'，则将距离栈s1栈顶的最近的'('之间的运算符，逐个出栈，依次压⼊栈s2，此时抛弃'('； 若x是除'('和')'外的运算符，则再分如下情况讨论： 若当前栈s1的栈顶元素为'('，则将x直接压⼊栈s1； 若当前栈s1的栈顶元素不为'('，则将x与栈s1的栈顶元素⽐较，若x的优先级⼤于栈s1栈顶运算符优先级，则将x直接压⼊栈s1。

例如：
产生式 语义子程序 (0)S` E {PRINT E•VAL} (1)E E (1)+E(2) {E•VAL= E (1) •VAL +E(2) •VAL } (2)E E (1)*E(2) {E•VAL= E (1) •VAL *E(2) •VAL } (3)E (E (1)) {E•VAL= E (1) •VAL } (4)E i {E•VAL= LEXVAL } 注：LEXVAL指的是词法分析送来的机内二进制整数
3、后缀表示式(逆波兰表达式) Operand1 Operand2 Operator 4、树形表示法
注：常用中间代码表示法是四元式。
赋值语句的翻译
仅含简单变量的表达式的赋值语句的翻译 1、赋值语句的文法 A i=E E E+E|E*E|-E|(E)|i 2、需要的语义过程 NEWTEMP函数：每次调用送回一个代表新临时 变量的序号，可认为是送回T1 、 T2这样的一些 临时变量 ENTRY(i)函数：用于查变量i的符号表入口地址
2、实例：对布尔式X+Y>Z∨A∧(┐B∨C)进行翻译: 解：语法制导得翻译是在语法分析的过程中进行的，若利
用G(B)文法的LR分析表对上句进行LR分析，在其过程中 进行语义分析；则得到的四元式序列是：



(+,X,Y,T1) ;E+E进行归约，识别了算术运算 (>, T1,Z, T2) ; E >E进行归约，识别了关系运算 (┐,B,_, T3) ; ┐E归约 (∨, T3,C, T4) ; E∨E进行归约 (∧,A, T4,T5) ; E∧E进行归约 (∨, T2, T5, T6) ; E∨E进行归约
四、常见的中间代码形式 1、四元式形式: (Operator,Operand1,Operand2,Result) 注： 1） Operand1,Operand2,Result 可能是用户自定 义的变量，也可能是编译时引进的变量。 这里 Operator是双目运算符，若只有一个运算量，则 是单目运算符。

逆波兰式的产生及计算一、目的与要求1、目的通过上机实习，加深对语法制导翻译原理的理解，掌握将语法分析所识别的语法范畴变换为某种中间代码的语义翻译方法。

2、要求（1）选用目前世界上普遍采用的语义分析方法──语法制导翻译技术。

（2）语义分析对象重点考虑经过语法分析后已是正确的语法范畴，实习重点是语义子程序。

（3）中间代码选用比较常见的形式，例如四元式。

二、背景知识属性文法：A=(G，V，F)，其中：G：一个CFG, 属性文法的基础。

V：有穷的属性集：每个属性与一个文法符号相关联，这些属性代表与文法符号相关的语义信息，如：类型、地址、值、代码、符号表内容等等。

属性与变量一样，可以进行计算和传递，属性加工的过程即是语义处理的过程。

属性加工与语法分析同时进行。

属性的表示：标始符（或数），写在相应文法的下边，点记法：E.Val,E.Place,E.Type…。

F：关于属性的属性断言或一组属性的计算规则(称为语义规则)。

断言或语义规则与一个产生式相联，只引用该产生式左端或右端的终结符或非终结符相联的属性。

属性有两类：综合属性：归约型属性，用于“自下而上”传递信息。

继承属性：推导型属性，用于“自上而下”传递信息。

综合属性的例子：非终结符E、T及F都有一个综合属性val,符号digit有一个综合属性，它的值由词法分析器提供。

与产生式L→E对应的语义规则仅仅是打印由E产生的算术表达式的值的一个过程，我们可认为这条规则定义了L的一个虚属性。

某些非终结符加上标是为了区分一个产生式中同一非终结符多次出现。

设表达式为3＊5+4，则语义动作打印数值19。

3*5+4的带注释的分析树继承属性的例子：继承属性的自上而下定值（Real id1，id2，id3）：Real id1，id2，id3的分析树L－属性文法：一个属性文法称为L－属性文法，如果对于每个产生式A→X1X2…Xn，满足：1、Xj（1≤j≤n）的继承属性仅依赖于下述属性值中的一种：A的继承属性或产生式右部位于Xj左边的符号X1，X2，…，Xj-1的属性。

如果题目是 S::=L.L | L L::=LB | B B::=0 | 1 则写成: S`::=S {print(S.val);} S::=L1.L2 { S.val:=L1.val+L2.val/2L2.length ;} S::= L { S.val:=L.val; } L::=L1B { L.val:=L1.val*2+B.val; L.length:=L1.length+1; } L::=B { L.val:=B.val; L.length:=1;} B::=0 { B.val:=0; } B::=1 { B.val:=1;}
如采用 LR 分析方法，给出表达式(5*4+8)*2 的语法树并在各结点注明语义值 VAL。
答案：
计算机咨询网（）陪着您
5
缄默TH浩的小屋
《编译原理》课后习题答案第八章
采用语法制导翻译思想，表达式 E 的“值”的描述如下：
产生式
语义动作
(0) S′→E
{print E.VAL}
四元式：
100 (+, a, b, t1) 101 (+, c, d, t2) 102 (*, t1, t2, t3) 103 (-, t3, /, t4) 104 (+, a, b, t5) 105 (+, t5, c, t6) 106 (-, t4, t6, t7)
树形：
计算机咨询网（）陪着您
计算机咨询网（）陪着您
6
缄默TH浩的小屋
《编译原理》课后习题答案第八章
第5题
令 S.val 为下面的文法由 S 生成的二进制数的值(如，对于输入 101.101，S.val=5.625)； SÆL.L | L LÆLB | B BÆ0 | 1

波兰式转换为逆波兰式（中缀表达式转换为后缀表达式）逆波兰式（Reverse Polish notation，RPN，或逆波兰记法），也叫后缀表达式（将运算符写在操作数之后）一、定义i=0; /*获取用户输入的表达式*/do{i++;cin>>str[i];/*此步我用的是C++ C语言的话在后面之所以用这个有一点区别都*/ //scanf("%c",&str[i]);}while(str[i]!='#' && i!=max);sum=i;t=1;i=1;ch=str[i];i++;//while(ch!='#'){switch(ch){case '(': /*判定为左括号*/top++;stack[top]=ch;break;case ')': /*判定为右括号*/while(stack[top]!='('){ex[t]=stack[top];top--;t++;}top--;break;case '+': /*判定为加减号*/case '-':while(top!=0&&stack[top]!='('){ex[t]=stack[top];top--;t++;}top++;stack[top]=ch;break;case '*': /*判定为乘除号*/case '/':while(stack[top]=='*'||stack[top]=='/'){ex[t]=stack[top];top--;t++;}top++;stack[top]=ch;break;case ' ':break;default:while(ch>='0'&&ch<='9'){ /*判定为数字*/ex[t]=ch;t++;ch=str[i];i++;}i--;ex[t]=' ';t++;}ch=str[i];i++;}while(top!=0){ex[t]=stack[top];t++;top--;}ex[t]=' ';printf("\n\t原来表达式：");for(j=1;j<sum;j++)printf("%c",str[j]);printf("\n\t逆波兰式：",ex);for(j=1;j<t;j++)printf("%c",ex[j]);}void compvalue(){ /*计算后缀表达式的值*/float stack[max],d; /*作为栈使用*/char ch;int t=1,top=0; /*t为ex下标，top为stack下标*/ch=ex[t];t++;while(ch!=' '){switch(ch){case '+':stack[top-1]=stack[top-1]+stack[top];top--;break;case '-':stack[top-1]=stack[top-1]-stack[top];top--;break;case '*':stack[top-1]=stack[top-1]*stack[top];top--;break;case '/':if(stack[top]!=0)stack[top-1]=stack[top-1]/stack[top];else{printf("\n\t除零错误!\n");exit(0); /*异常退出*/}top--;break;default:d=0;while(ch>='0'&&ch<='9'){d=10*d+ch-'0'; /*将数字字符转化为对应的数值*/ch=ex[t];t++;}top++;stack[top]=d;}ch=ex[t];t++;}printf("\n\t计算结果:%g\n",stack[top]);}void main(){trans();compvalue();}数据结构版int precede(char op){ int x;switch(op){case '*': x=2; break;case '/': x=2; break;case '+': x=1; break;case '-': x=1; break;default : x=0;}return x;}char *RPExpression(char *e){/* 返回表达式e的逆波兰式 */char *c;c=(char*)malloc(sizeof(char)*20); //不能用char c[] Stack s1;InitStack(s1);int i=0,j=0;char ch;Push(s1,'@');ch=e[i++];while(ch!= 0){if(ch=='('){Push(s1,ch);ch=e[i++];}else if(ch==')'){while(Top(s1)!='('){Pop(s1,c[j++]);}/* to[j++]=pop(&s1);*/Pop(s1,ch);ch=e[i++];}else if(ch=='+'||ch=='-'||ch=='*'||ch=='/'){char w;w=Top(s1);while(precede(w)>=precede(ch)){Pop(s1,c[j++]);w=Top(s1);}Push(s1,ch);ch=e[i++];}else{//while((ch<='z'&&ch>='a')||(ch<='Z' && ch>='A')){c[j++]=ch;ch=e[i++];//}//c[j++]=' ';}}Pop(s1,ch);while(ch!='@'){c[j++]=ch;Pop(s1,ch);}//c[j++]=;c[j++]=0;return c;}还有一种方法,用2叉树.二叉树法将最终进行的运算符记为根节点，将两边的表达式分别记为左右子树，依次进行直到所有的运算符与数字或字母标在一棵二叉树上。

实验报告成绩：指导教师审核（签名）：年月日预习报告□实验报告□语法制导把表达式翻译成逆波兰式(一)实验目的进一步掌握语法制导翻译的概念，理解中间语言，设计出错处理程序方法，掌握把表达式翻译成中间语言的算法。

(二)实验内容1．从左到右扫描中缀表达式，经语法分析找出中缀表达式出现的错误并给出错误的具体位置和类型。

一个运算符栈存放暂时不能出现的运算符，逆波兰区存放逆波兰表达式。

2．测试所编程序，给出正确和错误的结果。

(三)实验要求1．学生课前要认真阅读实验指导，理解实验内容与相关理论知识的关系，并完成预习报告2．用C语言或其它高级语言编写程序3．写出实验报告实验报告成绩：指导教师审核（签名）：年月日预习报告□实验报告□语法制导把表达式翻译成逆波兰式(一)实验目的通过上机实习加深对语法指导翻译原理的理解，掌握运算符优先权的算法，将语法分析所识别的表达式变换成中间代码的翻译方法。

(二)实验内容同预习报告(三)实验要求1.学生课前要认真阅读实验指导，理解实验内容与相关理论知识的关系，并完成预习报告2．用C语言或其它高级语言编写程序3．写出实验报告(四)实验设计思路1）表达式生成逆波兰式的算法1、初始化△送到运算符栈。

2、扫描左括号“（”，把△送到运算符栈。

3、扫描到变量，把它送到逆波兰区。

4、扫描到运算符( 1)栈内运算符比较a.栈内运算符>=栈外运算符，把栈内运算符送到逆波兰区。

b.栈内运算符<栈外运算符，把栈外运算符入栈。

( 2 ) 栈内是△把运算符入栈。

5、扫描右括号“)”。

( 1 )栈内是运算符，把栈内运算符送到逆波兰区。

( 2 )栈内是△则△退栈，读入下一个字符。

6、扫描到#（结束符）( 1 )栈内是运算符，把栈内运算符送到逆波兰区。

( 2 )栈内是△结束，否则继续分析。

(五)程序流程图(五)//#include<stdio.h>#include#define LEN 50 int main() {char stack[LEN];char exp[LEN];char str[LEN];char ch;int i=-1,j=0,top=0,flag=0;printf("请输入表达式以#号结束:\n");scanf("%s",str);lab:i++;ch=str[i];if(ch=='#')goto lab1;else if((ch>='0'&&ch<='9')||(ch>='a'&&ch<='z')) {exp[j]=ch;j++;goto lab;}else if(ch=='('||ch=='^'){top++;stack[top]=ch;goto lab;}else if(ch=='+'||ch=='-'){while(top!=0&&stack[top]!='('){exp[j]=stack[top];top--;j++;}top++;stack[top]=ch;goto lab;}else if(ch=='*'||ch=='/'){while(stack[top]=='*'||stack[top]=='/'){exp[j]=stack[top];top--;j++;}top++;stack[top]=ch;goto lab;}else if(ch==')'){while(stack[top]!='('){exp[j]=stack[top];j++;top--;}top--;goto lab;}else{printf("出错字符是：%c\n",str[i]);printf("出错位置是：%d\n",i+1);flag=1;}lab1:while(!flag&&top!=0){exp[j]=stack[top];j++;top--;}top=j;if(!flag){j=0;printf("逆波兰式为：\n");while(j<top+1){printf("%c",exp[j]);j++;}}return 0;}(六)程序运行结果测试测试结如下图，测试结果符合实验要求。

中缀表达式转换成逆波兰式数据结构c语言在计算机科学领域，中缀表达式和逆波兰式是两种常见的数学表达方式。

中缀表达式是我们日常生活中最为熟悉的数学表达方式，通常是由运算符和操作数构成的代数表达式，比如：(3 + 4) * 5。

而逆波兰式则是将操作符置于操作数之后的一种数学表达方式，比如：“3 4 + 5 *”。

在本文中，我们将深入探讨中缀表达式如何转换成逆波兰式，并结合数据结构和C语言编程，来实现这一转换过程。

通过这样的方式，我们不仅能够更深入地理解中缀表达式和逆波兰式的本质及其在计算机科学领域中的重要性，同时也能够加深对数据结构和C语言编程的理解。

1. 中缀表达式和逆波兰式的概念让我们简单回顾一下中缀表达式和逆波兰式的概念。

在中缀表达式中，操作符位于操作数之间，例如：3 + 4 * 5。

而逆波兰式则采用后缀表达方式，操作符位于操作数之后，例如：3 4 5 * +。

2. 数据结构的选择在将中缀表达式转换成逆波兰式的过程中，我们需要选择合适的数据结构来存储中间结果和最终结果。

在这里，我们选择使用栈这一数据结构。

栈是一种后进先出的数据结构，非常适合处理中缀表达式转换成逆波兰式的过程。

3. 中缀表达式转换成逆波兰式的算法接下来，我们将介绍中缀表达式转换成逆波兰式的算法。

该算法主要通过遍历中缀表达式，并使用栈来处理操作符的优先级和操作数的顺序。

具体的转换过程可以分为以下几个步骤： 1. 从左至右遍历中缀表达式的每个元素 2. 如果是操作数，则直接输出 3. 如果是左括号，则将其压入栈中 4. 如果是操作符，则比较其与栈顶操作符的优先级，如果栈顶操作符优先级较高，则将栈顶操作符弹出并输出，直到栈为空或者遇到了左括号 5. 如果是右括号，则将栈中左括号之前的所有操作符全部弹出并输出 6. 遍历完毕后，将栈中剩余的所有操作符依次弹出并输出4. C语言实现中缀表达式转换成逆波兰式在C语言中，我们可以使用数组来模拟栈的操作。

逆波兰式与表达式求值何为波兰式？何为逆波兰式？如何与表达式求值联系起来？波兰式、逆波兰式是数据结构和编译原理⾥⾯提到的知识点，我们平时的运算式都是这样的2 + 3 * (5 - 1)-10（中缀表达式），这样表达式易于阅读和计算，但是对于计算机这样就有点懵逼了。

前缀表达式：⽐如2 + 3 * (5 - 1)这个表达式的前缀表达式为+ 2 * 3 - 5 1来表⽰波兰表达式中缀序表达式：⽐如 2 + 3 * (5 - 1)-10后缀表达式：⽐如2 + 3 * (5 - 1)⽤逆波兰式来表⽰则是：2 3 5 1 - * + 逆波兰表达式求表达式值：["2", "1", "+", "3", "*"] -> ((2 + 1) * 3) -> 9["4", "13", "5", "/", "+"] -> (4 + (13 / 5)) -> 6问题可以转换为遍历表达式⽤⼀个堆来存数字，当遇见操作符的时候，弹出两个数字执⾏相应的运算，再压⼊堆⾥⾯，最后返回出来的就是运算表达式的结果。

public class Test {public static void main(String[] args) throws IOException {String[] tokens = new String[] { "2", "1", "+", "3", "*" };System.out.println(evalRPN(tokens));}public static int evalRPN(String[] tokens) {int returnValue = 0;String operators = "+-*/";Stack<String> stack = new Stack<String>();for (String t : tokens) {if (!operators.contains(t)) { //push to stack if it is a numberstack.push(t);} else {//pop numbers from stack if it is an operatorint a = Integer.valueOf(stack.pop());int b = Integer.valueOf(stack.pop());switch (t) {case "+":stack.push(String.valueOf(a + b));break;case "-":stack.push(String.valueOf(b - a));break;case "*":stack.push(String.valueOf(a * b));break;case "/":stack.push(String.valueOf(b / a));break;}}}returnValue = Integer.valueOf(stack.pop()); return returnValue;}}。

表达式逆波兰式
“逆波兰式”是一种特殊的数学计算表达式，由参与者按某种特定次序指定的算术符号组成，也称做逆波兰表达式。

“逆波兰式”的核心原理，即先处理的操作数位于后处理的操作数后面，这也就被称之为“后缀表达式”。

逆波兰式扮演着非常重要的角色，它的应用被广泛的用在计算机科学、编程语言、计算系统、数据库等各个领域。

它用来解决和处理基础数据、运行条件、算法及逻辑，对数据进行分析和判断，从而实现数学表达式、表达式强度以及表达式计算的要求。

逆波兰式是由一系列有序的符号组成，其中操作符被安排在操作数之后，而不像传统的运算中，操作符位于操作数之前。

这意味着，在使用逆波兰式之前，你需要知道运算的每一步细节，因为所有的操作符和操作数都是在一行中按顺序出现的。

逆波兰式当中的操作符有一个特殊的功能，即“结束符号”，它是将多个运算表达式连接起来用于完成某种功能的重要元素。

逆波兰
式还可以用来处理数组、循环等复杂的算法，从而更容易实现某种特定的计算。

由于它的方便性、易操作性和高度灵活性，逆波兰式作为计算机科学的一个基础，已经被广泛的应用于各种行业领域，它不仅能够为机器提供更高的智能，而且利用它来处理现实世界的局限性，可以更简单和高效的解决许多复杂的问题。

总之，逆波兰式是一种既灵活又易操作的表达式，它已经被广泛应用于计算机科学、数据库、计算系统等领域，它使得我们可以更简单和高效地解决复杂问题，为机器提供更高的智能。