中缀算术表达式的轻量化求值算法
关于中缀表达式求值（四则运算和括号，支持多位数）
关于中缀表达式求值（四则运算和括号，⽀持多位数）1.中缀转后缀和计算后缀表达式 1.1 中转后1. 数字则输出2. 如果是 "(" ,直接⼊栈3. 如果是 ")", 栈顶元素出栈并输出，直到遇到" ("，只弹出。
4. 如果栈空，直接⼊栈，否则和栈顶⽐较优先级，当⼤于栈顶时，⼊栈，否则，栈顶元素退栈，直到⼤于栈顶或栈空5. 中缀表达式扫描完毕，若栈不空，将其内所有元素弹出。
1.2 计算后缀1. 数字则⼊栈2. 运算符，出栈b,再出栈a 计算c=a operate b,将c⼊栈3. 中缀表达式扫描完毕，将栈内唯⼀的元素（也就是求的值）弹出并返回。
2.代码如下import java.util.*;import java.util.regex.Matcher;import java.util.regex.Pattern;;public class Test4 {private static Map<Character,Integer> map=new HashMap<>();static {map.put('+', 0);map.put('-', 0);map.put('*', 1);map.put('/', 1);}private static List<String> toPost(String target){List<String> post=new ArrayList<>();Stack<Character> stk=new Stack<>();Pattern p=pile("\\d+|\\D");Matcher m=p.matcher(target);while(m.find()) {String e=m.group();if(e.matches("\\d+"))post.add(e);else if(e.equals("("))stk.push('(');else if(e.equals(")")){while(stk.peek()!='(')post.add(stk.pop()+"");stk.pop();}else {char op=e.charAt(0);while(!stk.isEmpty()&&stk.peek()!='('&&map.get(op)<=map.get(stk.peek()))post.add(stk.pop()+"");stk.push(op);}}while(!stk.isEmpty()) post.add(stk.pop()+"");return post;}private static int calcuPost(List<String> post) {Stack<Integer> stk=new Stack<>();for(String s:post) {if(s.matches("\\d+")) stk.push(Integer.parseInt(s));else {char c=s.charAt(0);int b=stk.pop();int a=stk.pop();int t=0;if(c=='+')t=a+b;else if(c=='-')t=a-b;else if(c=='*')t=a*b;elset=a/b;stk.push(t);}}return stk.pop();}public static void main(String[] args) {Scanner is=new Scanner(System.in);while(is.hasNext()) {String exp=is.next();System.out.println(calcuPost(toPost(exp))); }is.close();}}。
表达式求值的经典算法
表达式求值的经典算法达式求值的经典方法由 Donald Knuth 描述于 1962 年（请参阅参考资料）。
Knuth 将此概括为三个步骤：对中缀表达式进行语法分析中缀表达式到后缀表达式的转换对后缀表达式求值注意到我们谈到的这个经典算法有些简化：算术表达式只包含操作数、二元操作符和一种括号。
此外，对于每个操作数和操作符，只用单个字符表示，使语法分析直观。
表达式表示法算术表达式中最常见的表示法形式有中缀、前缀和后缀表示法。
中缀表示法是书写表达式的常见方式，而前缀和后缀表示法主要用于计算机科学领域。
中缀表示法中缀表示法是算术表达式的常规表示法。
称它为中缀表示法是因为每个操作符都位于其操作数的中间，这种表示法只适用于操作符恰好对应两个操作数的时候（在操作符是二元操作符如加、减、乘、除以及取模的情况下）。
对以中缀表示法书写的表达式进行语法分析时，需要用括号和优先规则排除多义性。
Syntax: operand1 operator operand2Example: (A+B)*C-D/(E+F)前缀表示法前缀表示法中，操作符写在操作数的前面。
这种表示法经常用于计算机科学，特别是编译器设计方面。
为纪念其发明家― Jan Lukasiewicz（请参阅参考资料），这种表示法也称波兰表示法。
Syntax : operator operand1 operand2Example : -*+ABC/D+EF后缀表示法在后缀表示法中，操作符位于操作数后面。
后缀表示法也称逆波兰表示法（reverse Polish notation，RPN），因其使表达式求值变得轻松，所以被普遍使用。
Syntax : operand1 operand2 operatorExample : AB+C*DEF+/-前缀和后缀表示法有三项公共特征：操作数的顺序与等价的中缀表达式中操作数的顺序一致不需要括号操作符的优先级不相关中缀表达式到后缀表达式的转换要把表达式从中缀表达式的形式转换成用后缀表示法表示的等价表达式，必须了解操作符的优先级和结合性。
C#算术表达式求值（后缀法），看这一篇就够了
C#算术表达式求值（后缀法），看这⼀篇就够了⼀、种类介绍算术表达式有三种：前缀表达式、中缀表达式和后缀表达式。
⼀般⽤的是中缀，⽐如1+1，前后缀就是把操作符移到前⾯和后⾯，下⾯简单介绍⼀下这三种表达式。
1、前缀表⽰法前缀表⽰法⼜叫波兰表⽰法，他的操作符置于操作数的前⾯（例：+ 1 2），是波兰数学家扬·武卡谢维奇1920年代引⼊的，⽤于简化命题逻辑。
因为我们⼀般认为操作符是在操作数中间的，所以在⽇常⽣活中⽤的不多，但在计算机科学领域占有⼀席之地。
⼀般的表⽰法对计算机来说处理很⿇烦，每个符号都要考虑优先级，还有括号这种会打乱优先级的存在，将使计算机花费⼤量的资源进⾏解析。
⽽前缀表⽰法没有优先级的概念，他是按顺序处理的。
举个例⼦：9-2*3这个式⼦，计算机需要先分析优先级，先乘后减，找到2*3，再进⾏减操作；化成前缀表⽰法就是：- 9 * 2 3，计算机可以依次读取，操作符作⽤于后⼀个操作数，遇到减就是让9减去后⾯的数，⽽跟着9的是乘，也就是说让9减去乘的结果，这对计算机来说很简单，按顺序来就⾏了。
2、中缀表⽰法这也就是我们⼀般的表⽰法，他的操作符置于操作数的中间（例：1 + 2），前⾯也说过这种⽅法不容易被计算机解析，但他符合⼈们的普遍⽤法，许多编程语⾔也就⽤这种⽅法了。
在中缀表⽰法中括号是必须有的，要不然运算顺序会乱掉。
3、后缀表⽰法后缀表⽰法⼜叫逆波兰表⽰法，他的操作符置于操作数的后⾯（例：1 2 +），他和前缀表⽰法都对计算机⽐较友好，但他很容易⽤堆栈解析，所以在计算机中⽤的很多。
他的解释过程⼀般是：操作数⼊栈；遇到操作符时，操作数出栈，求值，将结果⼊栈；当⼀遍后，栈顶就是表达式的值。
因此逆波兰表达式的求值使⽤堆栈结构很容易实现，且能很快求值。
注意：逆波兰记法并不是简单的波兰表达式的反转。
因为对于不满⾜交换律的操作符，它的操作数写法仍然是常规顺序，如，波兰记法/ 6 3的逆波兰记法是6 3 /⽽不是3 6 /；数字的数位写法也是常规顺序。
数据结构表达式求值(中缀)实验报告
数据结构表达式求值（中缀）实验报告题目名称表达式求值学号姓名指导教师日期一1. 问题描述：在计算机中，算术表达式由常量、变量、运算符和括号组成。
由于不同的运算符具有不同的优先级，又要考虑括号，因此，算术表达式的求值不可能严格地从左到右进行，在程序设计时，借助栈实现。
2. 表达式求值这个程序，主要利用栈和数组，把运算的先后步骤进行分析并实现简单的运算，以字符列的形式从终端输入语法的正确的、不含变量的整数表达式。
利用已知的算符优先关系，实现对算术四则运算的求值，在求值中运用栈、运算栈、输入字符和主要操作的变化过程。
该程序相当于一个简单的计算机计算程序，只进行简单的加减乘除和带括号的四则运算。
1、基本思想（中缀表达式求值）要把一个表达式翻译成正确求值的一个机器指令序列，或者直接对表达式求值，首先要能够正确解释表达式，要了解算术四则运算的规则即：（1）先乘除后加减；（2）从左到右计算；（3）先括号内，后括号外。
下表定义的运算符之间的关系:b + - * / （） # a+ > > < < < > > _ > > < < < > > * > > > > < > > / > > > > < > > ( < < < < < = ) > > > > > > # < < < < < =为了实现运算符有限算法，在程序中使用了两个工作栈。
分别是：运算符栈OPTR,操作数栈OPND.基本思想：（1）首先置操作数栈为空栈，表达式起始符“#”为运算符栈的栈底元素；（2）依次读入表达式中每个字符，若是操作数则进OPND栈，若是运算符则和OPTR栈得栈顶运算符比较优先级后作相应操作。
c语言实现中缀表达式的计算
c语言实现中缀表达式的计算C语言实现中缀表达式的计算一、前言在计算机科学领域，中缀表达式是最容易理解的数学表达式，也是人们最常用的表达方式。
但对于计算机而言，中缀表达式并不方便计算。
因此，在进行表达式计算时，需要将中缀表达式转化为其它形式，例如前缀表达式和后缀表达式。
在本篇文章里，我们将介绍如何使用C语言实现中缀表达式的计算。
二、中缀表达式的转换在C语言中，实现中缀表达式的计算，通常需要先将中缀表达式转换为后缀表达式。
中缀表达式的转换过程主要分为以下三个步骤：1. 初始化一个栈，存储操作符。
2. 遍历中缀表达式，根据操作符的运算优先级将其从中缀表达式转化为后缀表达式。
3. 根据后缀表达式，使用栈实现表达式的计算。
其中，第二步是最关键的一个步骤。
我们可以通过以下方法进行转换：1. 将操作数直接输出。
2. 如果遇到运算符，先将栈中所有优先级大于等于该运算符的操作符弹出，再将该运算符入栈。
3. 如果遇到左括号，直接入栈。
4. 如果遇到右括号，将栈中的元素一直弹出到遇到左括号为止。
例如，对于中缀表达式2 + 3 * 4 - 5，转换为后缀表达式的过程如下所示：中缀表达式：2 + 3 * 4 - 5转换为后缀表达式：2 3 4 * + 5 -三、代码实现现在，我们已经掌握了中缀表达式的转换方法，接下来，我们就可以实现C语言代码了。
具体实现如下：#include <stdio.h>#include <stdlib.h>#include <string.h>// 定义运算符栈char op_stack[100];// 定义数字栈int num_stack[100];// 定义存储后缀表达式的数组char postfix[100];// 定义存储后缀表达式的栈顶指针int postIndex = 0;// 获取优先级int getPriority(char op){switch(op){case '+':case '-':return 1;case '*':case '/':return 2;case '(':case ')':return 0;}return -1;}// 中缀表达式转换为后缀表达式void infixToPostfix(char* infix){// 定义中缀表达式的指针char* ptr = infix;// 定义操作符栈顶指针int opTop = 0;while(*ptr != '\0'){if(*ptr >= '0' && *ptr <= '9') // 如果是数字，直接存入后缀表达式{postfix[postIndex++] = *ptr;}else if(*ptr == '(') // 如果是左括号，先入栈{op_stack[opTop++] = *ptr;}else if(*ptr == ')') // 如果是右括号，将栈中元素全部弹出{while(op_stack[opTop-1] != '('){postfix[postIndex++] = op_stack[--opTop];}opTop--;}else // 如果是运算符{while(opTop > 0 && getPriority(op_stack[opTop-1]) >= getPriority(*ptr)) // 将栈中优先级大于等于当前运算符的元素全部弹出{postfix[postIndex++] = op_stack[--opTop];}op_stack[opTop++] = *ptr; // 将当前运算符入栈}ptr++;}while(opTop > 0) // 将栈中剩余运算符全部弹出{postfix[postIndex++] = op_stack[--opTop];}}// 计算后缀表达式int calculate(char* postfix){// 定义后缀表达式的指针char* ptr = postfix;// 定义数字栈顶指针int numTop = 0;while(*ptr != '\0'){if(*ptr >= '0' && *ptr <= '9') // 如果是数字，直接入栈{num_stack[numTop++] = *ptr - '0';}else // 如果是运算符{int num2 = num_stack[--numTop];int num1 = num_stack[--numTop];switch(*ptr){case '+':num_stack[numTop++] = num1 + num2;break;case '-':num_stack[numTop++] = num1 - num2;break;case '*':num_stack[numTop++] = num1 * num2;break;case '/':num_stack[numTop++] = num1 / num2;break;}}ptr++;}return num_stack[0];}// 测试函数void test(char* infix){printf("中缀表达式：%s\n", infix);infixToPostfix(infix);printf("后缀表达式：%s\n", postfix);int result = calculate(postfix);printf("计算结果：%d\n", result);printf("--------------------------\n");}// 主函数int main(){test("2 + 3 * 4 - 5");test("3 + 4 * 2 / (1 - 5) ^ 2");return 0;}四、总结通过以上代码实现，我们可以看到中缀表达式的计算过程，其实就是将中缀表达式转化为后缀表达式的过程，并使用栈进行计算。
中缀表达式值
中缀表达式值的求解方法。
中缀表达式值的求解方法中缀表达式是我们常见的数学表达式形式，如 3 + 4.2×(8-5)，但是对于计算机而言，更容易处理的是后缀表达式或前缀表达式，因此我们需要将中缀表达式转换成后缀表达式或前缀表达式，再进行计算。
而将中缀表达式转换成后缀表达式或前缀表达式的过程，就称为表达式的转换。
本文将介绍两种方法，一种是使用栈的方法，另一种是使用递归的方法。
无论哪种方法，我们首先需要了解中缀表达式中的运算符的优先级和结合性。
运算符的优先级和结合性在中缀表达式中，我们常见的运算符有加减乘除、括号等，它们的优先级和结合性如下：运算符 | 优先级 | 结合性:--------:|:------:|:------:( ) | 无 | 左结合+ - | 1 | 左结合× ÷ | 2 | 左结合其中，优先级数字越大，优先级越高。
左结合表示从左往右计算，右结合表示从右往左计算。
使用栈的方法栈是一种后进先出的数据结构，对于中缀表达式的转换，我们可以使用栈来存储运算符。
具体过程如下：1. 创建两个栈，一个用来存储运算符，一个用来存储中间结果；2. 从左到右遍历中缀表达式中的每一个元素；3. 如果是数字，则直接压入中间结果栈；4. 如果是运算符，则判断与运算符栈栈顶元素的优先级，如果优先级较高，则直接入栈；如果优先级较低，则将运算符栈中优先级较高的运算符弹出，压入中间结果栈，直到优先级相等或者运算符栈为空，再将该运算符压入运算符栈；5. 如果是左括号，则直接压入运算符栈；6. 如果是右括号，则将运算符栈中从左到右第一个左括号上面的运算符全部弹出，压入中间结果栈，将左括号弹出丢弃；7. 遍历完中缀表达式后，将运算符栈中的所有运算符弹出，压入中间结果栈。
根据上述过程，我们可以将中缀表达式 3 + 4.2×(8-5) 转换成后缀表达式 3 4.2 85 - × +。
中缀表达式求值
一、设计思想用堆栈中缀法实现表达式自动计算的基本思路是：定义两个栈，一个为操作符栈，用来存放操作符的；另一个为操作数栈，用来存放操作数。
还有一个字符型数组，用来存放输入的表达式。
从数组中开始扫描第一个字符w，每扫描一个字符后，根据w的不同情况分别做以下处理：如果是操作符，那么判断w与操作符的栈顶的优先级。
如果大于，直接将w压入操作符栈。
如果小于，则将操作符的栈顶弹栈，再将操作数栈的栈顶和次栈顶弹栈，并和操作符的栈顶进行计算，结果直接进入操作数栈。
如果w不是操作符，判断它是整数还是小数，是一位的还是多位的。
如果操作符的栈顶元素是#，并且从表达式数组中扫描进来的也是#，运算结束，操作数的栈顶元素就是计算结果。
二、算法流程图中缀表达式求值算法流程图简单说明：将输入的字符表达式存到数组中，对数组中的元素进行遍历，当读入第一个字符时先判断它是不是操作数然后判断它是不是多位浮点型小数。
如果是操作符，就判断它的优先级和操作符栈栈顶的优先级，谁的优先级比较高，如果是栈顶的优先级大于输入的字符，那么将栈顶的元素a出栈，再从操作数栈弹出栈顶和次栈顶，并进行次栈顶和栈顶关于a的运算，结果送回到操作数栈，然后扫描下一个字符。
如果它是操作数，那么要判断它是一位数还是多位数，是小数还是整数，如果是小数或者是多位的，那么执行多位数处理程序。
三、源代码下面给出的是用中缀表达式求值算法实现的程序的源代码：#define N 50#include<ctype.h>#include<string.h>#include<stdio.h>#include<math.h>typedef struct{int top;double array[N];}NumStack;//操作数栈类型typedef struct{int top;char array[N];}OpStack;//操作符栈类型int Cint(char mychar){return (mychar-48);}//字符转换成数字void PushNum(NumStack *numstack,double num){numstack->top++;numstack->array[numstack->top-1]=num;}//操作数进栈void PopNum(NumStack *numstack,double*num){*num=numstack->array[numstack->top-1];numstack->top--;}//操作数出栈void PushOp(OpStack *opstack,char op){opstack->top++;opstack->array[opstack->top-1]=op;}//操作符进栈void PopOp(OpStack *opstack,char*op){*op=opstack->array[opstack->top-1];opstack->top--;}//操作符出栈double Calc(double a,double b,char c){double result;switch(c){case'+':result=a+b;break;case'-':result=a-b;break;case'*':result=a*b;break;case'/':result=a/b;break;}return result;}//计算两个操作数按c进行运算char Priority(char y,char x){char priority='<';switch(x){case'+':case'-':if(y=='('|| y=='#')priority='>';break;case'*':case'/':if(y=='('|| y=='#'|| y=='+'|| y=='-')priority='>';break;case'(':priority='>';break;case')':if(y=='(')priority='=';break;case'#':if(y=='#')priority='=';break;default:priority='E';}return priority;}//比较两个操作符的优先级void Process(NumStack *numstack,OpStack *opstack,char x){double a,b;char c;static double tempnum=0.00000000;static int len=10;static intdot=0,flags=0;if(isdigit(x) || x=='.'){if(x=='.')dot=1;else{if(dot==0)tempnum=tempnum*10+Cint(x);//整数部分两位以上的数else{tempnum=tempnum+(double)Cint(x)/len;//小数部分两位以上的数len*=10;}}}else{if(flags==0 &&x!='('){PushNum(numstack,tempnum);tempnum=0.00000000;len=10;dot=0;} switch(Priority(opstack->array[opstack->top-1],x)){case'>':PushOp(opstack,x);flags=0;break;case'<':PopOp(opstack,&c);PopNum(numstack,&b);PopNum(numstack,&a);PushNum(numstack,Calc(a,b,c));flags=1;Process(numstack,opstack,x);break;case'=':PopOp(opstack,&c);flags=1;break;default:printf("Wrong Express!");exit(0);}}}main(){NumStack numstack;OpStack opstack;//定义栈char s[N];int i=0;numstack.top=0;opstack.top=0;//初始化栈PushOp(&opstack,'#');//操作符栈底为#printf("\nEnter your expression and end it with #:");scanf("%s",s); for(i=0;i<strlen(s);i++)Process(&numstack,&opstack,s[i]);printf("The result is %f",numstack.array[numstack.top-1]);}。
中缀求值实验报告
一、实验目的1. 理解中缀表达式及其求值原理。
2. 掌握中缀表达式的转换方法，即将中缀表达式转换为后缀表达式。
3. 实现中缀表达式的求值算法，并编写相应的程序。
二、实验原理中缀表达式是一种常见的数学表达式表示方式，其特点是运算符位于操作数之间。
例如，表达式 "3 + 4 2" 就是一个中缀表达式。
中缀表达式转换为后缀表达式（也称为逆波兰表达式）是求值的关键步骤，因为后缀表达式可以直接按照运算符的优先级进行计算。
中缀表达式转换为后缀表达式的基本原理如下：1. 创建一个栈，用于存储运算符。
2. 从左到右扫描中缀表达式中的每个字符。
3. 如果是操作数，直接输出到结果字符串。
4. 如果是运算符，比较当前运算符的优先级与栈顶运算符的优先级。
a. 如果栈为空或者栈顶元素是左括号 "(", 将当前运算符压入栈中。
b. 如果当前运算符的优先级高于栈顶运算符的优先级，或者栈顶元素是右括号")", 将当前运算符压入栈中。
c. 如果当前运算符的优先级低于或等于栈顶运算符的优先级，将栈顶运算符弹出并输出到结果字符串，然后重复步骤 4。
5. 当扫描完中缀表达式后，将栈中的所有运算符依次弹出并输出到结果字符串。
6. 将中缀表达式转换为后缀表达式后，按照后缀表达式的规则进行求值。
三、实验步骤1. 定义一个函数，用于判断字符是否为操作数。
2. 定义一个函数，用于判断字符是否为运算符。
3. 定义一个函数，用于判断运算符的优先级。
4. 定义一个函数，用于将中缀表达式转换为后缀表达式。
5. 定义一个函数，用于求值后缀表达式。
6. 编写主函数，实现中缀表达式的求值。
四、实验代码```pythondef is_operand(c):return c.isdigit()def is_operator(c):return c in ['+', '-', '', '/', '(', ')']def precedence(op):if op in ['+', '-']:return 1if op in ['', '/']:return 2return 0def infix_to_postfix(expression):stack = []postfix = []for c in expression:if is_operand(c):postfix.append(c)elif c == '(':stack.append(c)elif c == ')':while stack and stack[-1] != '(':postfix.append(stack.pop())stack.pop()else:while stack and precedence(stack[-1]) >= precedence(c): postfix.append(stack.pop())stack.append(c)while stack:postfix.append(stack.pop())return postfixdef evaluate_postfix(postfix):stack = []for c in postfix:if is_operand(c):stack.append(int(c))else:b = stack.pop()a = stack.pop()if c == '+':stack.append(a + b)elif c == '-':stack.append(a - b)elif c == '':stack.append(a b)elif c == '/':stack.append(a / b)return stack[0]def evaluate_infix(expression):postfix = infix_to_postfix(expression)return evaluate_postfix(postfix)# 主函数if __name__ == '__main__':expression = input("请输入中缀表达式：")result = evaluate_infix(expression)print("结果为：", result)```五、实验结果与分析1. 输入中缀表达式 "3 + 4 2"，程序输出结果为 11，与预期一致。
中缀表达式计算、
中缀表达式计算、（实用版）目录1.中缀表达式的概念2.中缀表达式的计算方法3.中缀表达式的应用实例正文一、中缀表达式的概念中缀表达式（Infix Expression），又称作中缀代数表示，是一种将运算符和操作数混合排列的表达式。
它是一种用于表示算术运算的记法，其中运算符出现在操作数之间。
与常见的前缀表达式（Postfix Expression）和后缀表达式（Reverse Polish Notation，简称 RPN）不同，中缀表达式的运算顺序取决于运算符的优先级和结合性。
二、中缀表达式的计算方法中缀表达式的计算过程需要通过一定的转换将其转换为可以被计算机直接执行的形式。
常见的计算方法有以下两种：1.栈算法栈算法是一种基于栈的数据结构，可以用来解决中缀表达式的计算问题。
该算法的基本思想是使用一个栈来存储中缀表达式中的操作数，当遇到运算符时，根据栈顶元素的类型进行相应的操作。
具体来说，可以将中缀表达式转换为后缀表达式，然后使用栈来计算后缀表达式的值。
2.直接计算法直接计算法是一种直接根据运算符的优先级和结合性计算中缀表达式的值的方法。
该方法需要先确定运算符的优先级，然后从左到右扫描表达式，根据优先级和结合性进行相应的计算。
这种方法相对简单，但对于复杂的表达式计算效率较低。
三、中缀表达式的应用实例中缀表达式在计算机科学中有广泛的应用，例如：1.表达式求值：通过中缀表达式计算方法，可以实现对复杂数学表达式的求值。
2.编译器：编译器在将高级编程语言转换为机器语言时，需要对表达式进行求值。
中缀表达式作为一种表达式表示方法，可以在编译器中得到应用。
3.数据库查询：在数据库查询中，常常需要对查询条件进行复杂的逻辑运算。
中缀表达式作为一种表达式表示方法，可以帮助用户更方便地表示查询条件。
总结：中缀表达式作为一种表达式表示方法，在计算机科学中有广泛的应用。
中缀 表达式 运算
中缀表达式运算中缀表达式是一种常见的数学表达式形式，其中运算符位于操作数之间。
在中缀表达式中，操作符的优先级决定了计算的顺序。
本文将介绍中缀表达式的基本概念、计算方法以及一些常见的应用场景。
一、中缀表达式的基本概念中缀表达式是一种常见的数学表达式形式，如"2 + 3"、"4 * (5 - 6)"等。
在中缀表达式中，操作数和运算符的顺序与我们通常书写数学表达式的方式相同。
例如，在表达式 "2 + 3"中，操作数为2和3，运算符为+。
二、中缀表达式的计算方法在计算中缀表达式时，我们需要考虑运算符的优先级。
例如，在表达式 "2 + 3 * 4"中，乘法的优先级高于加法，所以我们首先计算乘法部分，得到12，然后再与2相加，得到最终结果14。
为了准确计算中缀表达式，我们需要使用一些算法和数据结构。
其中，最常用的算法是转换为后缀表达式，然后使用栈来计算后缀表达式。
三、中缀表达式的转换方法将中缀表达式转换为后缀表达式是计算中缀表达式的关键步骤。
后缀表达式也称为逆波兰表达式，其中运算符位于操作数之后。
例如，将中缀表达式 "2 + 3 * 4"转换为后缀表达式的结果为 "2 3 4 * +"。
转换方法如下：1. 创建一个空栈和一个空列表。
2. 从左到右扫描中缀表达式的每个元素。
3. 如果元素是操作数，则将其添加到列表中。
4. 如果元素是左括号，则将其推入栈中。
5. 如果元素是右括号，则将栈中的元素弹出，直到遇到左括号。
将弹出的元素添加到列表中。
6. 如果元素是运算符，则将栈中优先级大于或等于该运算符的元素弹出，并将弹出的元素添加到列表中。
然后将该运算符推入栈中。
7. 扫描完整个表达式后，将栈中剩余的运算符弹出，并将它们添加到列表中。
8. 列表中的元素即为转换后的后缀表达式。
四、中缀表达式的应用场景中缀表达式在计算机科学和数学中有广泛的应用。
中缀表达式求值
中缀表达式求值中缀表达式求值中缀表达式是人类最常用的表达式形式，但是计算机不能直接理解和计算中缀表达式。
因此，我们需要将中缀表达式转换为计算机可以理解和计算的后缀表达式，然后再对后缀表达式进行求值。
一、中缀表达式转后缀表达式1. 基本原则：遵循运算符优先级和结合性原则。
2. 转换方法：（1）从左到右扫描中缀表达式的每个元素；（2）如果当前元素是数字，则直接输出到后缀表达式；（3）如果当前元素是左括号，则将其入栈；（4）如果当前元素是右括号，则将栈顶操作符出栈并输出到后缀表达式，直到遇到左括号为止；（5）如果当前元素是操作符，则比较其与栈顶操作符的优先级：a. 如果栈为空或栈顶操作符为左括号，则将该操作符入栈；b. 如果该操作符优先级大于栈顶操作符优先级，则将该操作符入栈；c. 否则，将栈顶操作符出栈并输出到后缀表达式，重复步骤5直至满足上述两个条件之一，然后将该操作符入栈。
（6）重复步骤2-5直至扫描完整个中缀表达式，如果栈中还有操作符，则依次出栈并输出到后缀表达式。
例如，将中缀表达式“3+4*5/(6-2)”转换为后缀表达式的过程如下：元素 | 操作 | 栈 | 后缀表达式---------|---------------|--------------|-----------3 | 直接输出 | | 3+ | 入栈 | + |4 | 直接输出 | | 3 4* | 入栈 | + * |5 | 直接输出 | | 3 4 5 */ | 比较优先级 | + / * |( | 入栈 | + / * ( |6 | 直接输出 | | 3 4 5 * 6- | 入栈 | + / * ( - |2 | 直接输出 | |345 *6 2 -) | 比较优先级 |- |- / *) |- |- |- / *+ |- |- |- / * +后缀表达式：3,4,5,*,6,2,-,/,+二、后缀表达式求值1. 基本原则：遵循运算符优先级和结合性原则。
算术中缀表达式求值（简单计算器的运算）
算术中缀表达式求值（简单计算器的运算）1. 转化中缀表达式直接求值实现并不现实，需要转化成后缀表达式才能求值。
1. 过程2. 开两个栈，⼀个为符号栈，⼀个为数字栈，分别执⾏不同的分⽀操作。
*当遇到左括号时⽴刻将其压⼈栈中，直到遇到右括号时将左右括号之间的符号和数字全部弹出运算。
*遇到⼀个数字时，将数字压⼊数字栈中。
*遇到⼀个运算符时，将运算符与栈顶运算符⽐较，有下列四种情况：1. 如果当前运算符⽐栈顶运算符优先级要⾼，或者为左括号后的第⼀个运算符，则将其压⼊栈中。
2. 如果它⽐栈中元素优先级低或⼩，则弹出栈顶运算符并运算。
3. 继续⽐较，如果他⽐新的栈顶运算符优先级⾼，则回到第⼀步，否则重复2,3步。
4. 如果扫描到了中缀表达式的末尾，则弹出所有运算符和相应位置的数字进⾏运算。
（如果碰到两位数，⽤标记数组先记录下来，再在计算中转化）3.代码展⽰（code.Js）1.两步分别为操作栈和运算#include<iostream>#include<stack>#include<cstring>#include<iomanip>using namespace std;char endnumber[100];//数字和字符栈char number[100];//两位数特殊下标int z = 0;//下标//a,b优先级⽐较bool cmp(char a,char b){if(a == '*'||a == '/'){if(b == '*'||b == '/'){return false;}else{return true;}}else{return false;}}//使⽤过渡栈存⼊后缀表达式void get_stack(string s){memset(number,1,sizeof(number));stack<char>attitude;int l = s.length();int i = 0;for(i = 0;i < l;i++){char t = s[i];if(t == '('){attitude.push(t);}else if(t == ')'){char str1 = attitude.top();while(str1 != '('){endnumber[z++] = str1;attitude.pop();str1 = attitude.top();attitude.pop();}else if(t >= '0'&&t <= '9'){if(s[i+1] >= '0'&&s[i+1] <= '9'){number[z] = '0';endnumber[z] = s[i];z++;endnumber[z] = s[i+1];z++;i++;}else{endnumber[z++] = s[i];}}else{if(attitude.empty()){attitude.push(t);}else{char str2 = attitude.top();if(cmp(t,str2) || str2 == '('){attitude.push(t);}else{while(!cmp(t,str2)&&str2 != '('&&!attitude.empty()){attitude.pop();endnumber[z++] = str2;if(!attitude.empty())str2 = attitude.top();}attitude.push(t);}}}}while(!attitude.empty()){char str3 = attitude.top();endnumber[z++] = str3;attitude.pop();}// for(i = 0;i < z;i++)// cout<<endnumber[i]<<" ";}//从存储中调出数字和字符进⾏计算,转换成浮点数计算精确值void get_calculate(string s){int k = 1;stack<float>put_stack;if(number[0] == '0'){put_stack.push(((endnumber[0] - '0')*10+(endnumber[1]-'0'))*1.0);k++;}elseput_stack.push(1.0*(endnumber[0] - '0'));for(int i = k;i < z;i++){char t = endnumber[i];if(t >= '0'&&t <= '9'){if(number[i] == '0'){put_stack.push(((endnumber[i] - '0')*10+(endnumber[i+1]-'0'))*1.0); i++;}else{put_stack.push((t - '0')*1.0);}}elsefloat x = put_stack.top();put_stack.pop();float y = put_stack.top();put_stack.pop();float tmp;if(t == '+')tmp = x+y;else if(t == '-')tmp = y-x;else if(t == '*')tmp = x*y;elsetmp = y/x;put_stack.push(tmp);}}cout<<setiosflags(ios::fixed)<<setprecision(2)<<put_stack.top(); }int main(){string exp_middle;//中缀表达式cin>>exp_middle;get_stack(exp_middle);get_calculate(exp_middle);return0;}。
中缀表达式求值
中缀表达式求值以中缀表达式求值为题，我们来探讨一下中缀表达式的求值过程。
什么是中缀表达式呢？中缀表达式是我们平时最常见的表达式形式，即运算符位于操作数的中间，例如2+3*4。
而求值则是指根据给定的表达式，计算出它的结果。
那么，中缀表达式的求值过程是怎样的呢？我们可以通过以下步骤来进行求值：1. 创建两个栈：一个用来存储操作数的栈，称为操作数栈；另一个用来存储运算符的栈，称为运算符栈。
2. 从左到右依次扫描中缀表达式的每个字符。
3. 如果当前字符是数字，将其压入操作数栈中。
4. 如果当前字符是运算符，则进行如下操作：a. 如果运算符栈为空，或者栈顶运算符为左括号"("，则将当前运算符压入运算符栈中。
b. 如果当前运算符的优先级高于栈顶运算符的优先级，则将当前运算符压入运算符栈中。
c. 否则，将运算符栈顶的运算符弹出，并将其压入操作数栈中，直到满足条件a或b为止。
然后将当前运算符压入运算符栈中。
5. 如果当前字符是左括号"("，则将其压入运算符栈中。
6. 如果当前字符是右括号")"，则进行如下操作：a. 将运算符栈顶的运算符弹出，并将其压入操作数栈中，直到遇到左括号"("。
并且将左括号"("从运算符栈中弹出，但不压入操作数栈中。
7. 如果扫描完整个表达式后，运算符栈中还有运算符，那么将其依次弹出，并压入操作数栈中。
8. 最后，操作数栈中的唯一元素即为中缀表达式的求值结果。
通过上述步骤，我们可以求得中缀表达式的值。
这个求值过程的核心思想是使用两个栈来辅助计算，通过比较运算符的优先级来确定运算的顺序。
需要注意的是，中缀表达式的求值过程中，还需要考虑运算符的优先级。
一般来说，乘除法的优先级高于加减法，而同一优先级的运算符则按照从左到右的顺序进行计算。
如果遇到优先级相同的运算符，则按照从左到右的顺序依次计算。
中缀算术表达式的轻量化求值算法
中缀算术表达式的轻量化求值算法作者：白宇郭显娥来源：《计算机应用》2013年第11期摘要：针对当前中缀算术表达式求值算法笨重或者复杂的问题，提出了一种轻量化的中缀算术表达式求值算法。
该算法基于逆向拆分中缀算术表达式的思路，使用递归解析的方法，等价于中缀算术表达式的构造二叉树表示。
实验结果表明，该算法与传统逆波兰表达式（RPN）转换、求值算法相比，该算法无需做逆波兰表达式转换，无需人工栈辅助，实现代码量仅有其1/6，而效率仅下降6.9%。
与W3Eval算法相比，该算法无需符号转置表，支持算符自定义或重定义，实现代码量不到其1/2。
该算法实现代价低，适用于Web应用的Browser端，及嵌入式应用等轻量化应用场合。
关键词：轻量化算法；中缀算术表达式；逆向拆分；逆波兰表达式；W3Eval0引言中缀算术表达式求值在编译系统以及各种涉及表达式计算的应用系统中被广泛使用。
中缀表示法是一种通用的算术式或逻辑式的表示方法，其算符是以中缀形式位于两个算数的中间[1]，例如：2+3。
中缀表示法与人类日常习惯相一致，因此最为常用，但在使用计算机对表达式求值时，中缀表示法有诸多不便[2-3]，故当前通用的是Donald Knuth于1962年提出的方法：将中缀表达式转换为后缀表达式，即逆波兰表达式（Reverse Polish Notation，RPN），然后再对RPN求值[1-3]。
该方法适应性良好，理论成熟完备，时间复杂度低，适合在编译等复杂系统中使用；但是，其缺点为算法笨重、代码量大，且中缀表达式转换为RPN，以及对RPN求值均需要人工栈辅助[1-3]。
当前，Web应用中的Browser端由ECMA（European Computer Manufacturers Association）脚本实现的算法需满足轻量化的要求[4]，嵌入式应用也要求算法轻量化，即结构简单，实现代价低，代码量小[5]。
其中用到中缀算术表达式求值的多为一些人机接口中的内容，并没有类似编译系统这样的复杂需求，故使用RPN求值带来的程序复杂性增加与Web应用Browser端和嵌入式应用的轻量化需求不符。
计算机表达式求值算法的最优化方法研究
计算机表达式求值算法的最优化方法研究计算机表达式求值是计算机程序设计中十分基本的操作。
表达式求值在程序设计中的应用非常广泛，例如计算器程序、科学计算、图形处理等等。
在大量数据计算的情况下，表达式求值的优化是非常重要的。
本文将就计算机表达式求值算法的最优化方法进行研究，探讨其优化方法和实现方式。
一、算法概述计算机表达式求值算法主要有两种方法：前缀表达式求值和中缀表达式求值。
在计算表达式的过程中，计算机需要将表达式转化为计算机可读的二进制数据，然后进行运算。
传统的计算机表达式求值算法大多使用栈结构来实现，但是随着计算机处理速度的不断提升，上述算法逐渐显现出一定的性能瓶颈。
为了改善传统算法性能不足的问题，目前提出了一些优化思路，包括减少计算机的内存使用、提高编译器的运算速度、优化数据结构等。
优化算法的出现大大提升了计算机表达式求值的效率。
二、优化算法1. 前缀表达式求值前缀表达式求值算法是一种把算符写在操作数前面的表达式求值方法。
例如“+12”就是一个前缀表达式，它的值为3。
前缀表达式求值算法通过遍历表达式求值，使用栈来存储数据。
在栈的处理过程中，函数的调用开销会增加计算的时间，因此针对这一问题，推出了一种堆栈分配的优化方法，将堆栈的内存分配给表达式节点，避免了大量栈的函数调用带来的额外计算时间。
2. 中缀表达式求值中缀表达式求值是一种把算符写在操作数中间的表达式求值方法。
例如“1+2”就是一个中缀表达式，它的值为3。
中缀表达式求值的优化方法主要有两种：使用树型结构、使用逆波兰表达式。
通过使用树型结构，可以将计算的过程分解成多个阶段，提高计算效率。
而逆波兰表示法则可以进行一定的计算优化，避免了括号与优先级的操作。
三、算法实现在实现过程中，应尽可能减少计算机的计算量和内存使用。
具体实现中，可以使用动态规划或者分治法等算法来减少计算量；使用位运算或者类似的实现方法来优化内存使用。
同时，要适当考虑代码的复杂度，提高代码可读性，利于后期维护和修改。
前中后缀表达式的计算方法
前中后缀表达式的计算方法前缀表达式的计算方法：从右往左扫描表达式，遇到数字则入栈，遇到运算符则取出栈顶的两个数字进行运算，将结果入栈，最后栈中剩下的数字即是表达式的结果。
例如，前缀表达式*+567的计算过程如下：1.从右往左扫描表达式。
2.遇到数字7，入栈，栈：7。
3.遇到数字6，入栈，栈：67。
4.遇到数字5，入栈，栈：567。
5.遇到运算符+，取出栈顶的两个数字6和7进行加法运算，将结果13入栈，栈：513。
6.遇到运算符*，取出栈顶的两个数字5和13进行乘法运算，将结果65入栈，栈：65。
7.最后栈中剩下的数字65即是表达式的结果。
中缀表达式的计算方法：将中缀表达式转换为后缀表达式后，再用后缀表达式的计算方法进行计算。
例如，中缀表达式1+2*3的计算过程如下：1.将中缀表达式转换为后缀表达式123*+。
2.从左往右扫描后缀表达式。
3.遇到数字1，入栈，栈：1。
4.遇到数字2，入栈，栈：12。
5.遇到数字3，入栈，栈：123。
6.遇到运算符*，取出栈顶的两个数字2和3进行乘法运算，将结果6入栈，栈：16。
7.遇到运算符+，取出栈顶的两个数字1和6进行加法运算，将结果7入栈，栈：7。
8.最后栈中剩下的数字7即是表达式的结果。
后缀表达式的计算方法：从左往右扫描表达式，遇到数字则入栈，遇到运算符则取出栈顶的两个数字进行运算，并将结果入栈，最后栈中剩下的数字即是表达式的结果。
例如，后缀表达式56+7*的计算过程如下：1.从左往右扫描后缀表达式。
2.遇到数字5，入栈，栈：5。
3.遇到数字6，入栈，栈：56。
4.遇到运算符+，取出栈顶的两个数字5和6进行加法运算，将结果11入栈，栈：11。
5.遇到数字7，入栈，栈：117。
6.遇到运算符*，取出栈顶的两个数字11和7进行乘法运算，将结果77入栈，栈：77。
7.最后栈中剩下的数字77即是表达式的结果。
c++ 中缀表达式
c++ 中缀表达式
C++ 中缀表达式是指常见的数学表达式，例如 2 + 3 4。
在这
种表达式中，操作符位于两个操作数之间。
在C++中，我们通常使
用中缀表达式来表示数学计算和逻辑运算。
在C++中，我们可以通过使用运算符和操作数来构建中缀表达式。
例如，我们可以使用加号 (+)、减号 (-)、乘号 ()、除号 (/) 等运算符来进行加减乘除运算。
此外，我们还可以使用括号来改变
运算的优先级，例如 (2 + 3) 4。
当我们使用中缀表达式时，C++ 编译器会根据操作符的优先级
和结合性来计算表达式的值。
例如，在表达式 2 + 3 4 中，乘法
运算会先于加法运算进行，因为乘法的优先级高于加法。
因此，这
个表达式的值为 14。
除了基本的数学运算，C++ 中还支持逻辑运算符（如 && 和 ||）以及比较运算符（如 == 和 !=）。
这些运算符也可以用于构建中缀
表达式，例如 a && b || c。
在C++中，我们可以使用中缀表达式来进行各种计算，但在某
些情况下，我们可能需要将中缀表达式转换为前缀或后缀表达式，以便计算机更容易地处理。
这可以通过算法来实现，例如使用栈来转换中缀表达式。
总的来说，中缀表达式是C++中常用的一种表达式形式，用于表示各种数学和逻辑运算。
中缀表达式简单算术表达式的C++求解
计算机软件技术基础作业一说明中缀表达式简单算术表达式的求解1、源程序见包内，经检测可以在MS VC++ 6.0中正确运行，可以输入800个符号内任意长度的中缀表达式，并拥有了判错功能；2、本题通过构造堆栈实现中缀表达式的运算；3、算法思路：用模板实现的链式结构堆栈类并且实现类模板成员函数，专门定义算法函数char Precede(char ch1,char ch2)进行运算，判别函数int Operator(char ch)判别运算符号是否正确，。
运算时根据优先级的大小进行：相等则消去括号；下一个大则压入下一个符号；前面大则先将前面数字算好，再将答案压入数字栈中。
最后将判错功能的算法加入程序中。
4、数据结构设计说明本程序使用了堆栈的方法，同时采用了数组形式作为数据结构。
5、程序流程说明建立栈压入栈计算输出结果6、程序运行的验证过程（1）正常运行（2）错误一（3）错误二（4）错误三（5）错误四（6）错误五（7）错误六（8）错误八7、效果分析：将数据压入一个堆栈中，分别读取数字符和运算符，中缀表达式由键盘输入，以回车键结束。
如：3*((4+6)-(5-2)^3)。
由于C++不能读取’\n’，所以该题目只能在读取到’\0’时算到最终结果。
程序给出算术表达式的精确结果，同时给出错误之处！比如中缀表达式中不能包含多余的空格；中缀表达式中的运算数由{0,1,…,8,9}中的单个数字组成；中缀表达式中只包含5种2目运算符：+，-，*，/ ,^及两种优先级运算符“（”和“）”等等。
8、原创内容及体会刚刚编写程序时，我按照老师课件进行。
但是遇到了不可解决的麻烦，其源程序见下：（请老师指点，邮箱：****************）#include<iostream>#include <math.h>#include<stdio.h>#include<stdlib.h>using namespace std;template <typename T>void initStack ( T *s, int m, int *top ){s = new T(m); // 动态申请容量为m的存储空间*top =0; // 栈顶指针return; // 当前分配的栈空间}template <typename T>void push ( T *s, int m, int *top, T x ){if (*top == m ){ cout<<"Stack overflow! "<<endl; return;}*top = *top+1; // 序号指针递增s[*top-1] =x; // 入栈return;}template <typename T>T pop( T *s, int m, int *top ){T y;if ( *top == 0){ cout<<"Stack underflow! "<<endl; return;}y = s[*top-1]; // 退栈*top = *top-1; // 序号指针递减return(y); //返回栈顶元素}int Operate (int a, char e, int b)//运算操作{int c;switch (e){case '+':{ c = a + b;break; }case '-':{c = a - b;break; }case '*':{c = a * b;break; }case '/':{c = a / b;break;}case '^':{c=pow(a,b);break;}default:printf ("error\n");}return c;}char Precede(char ch1,char ch2) {char ch;switch(ch1){case '+':case '-':{switch(ch2){case '+':case '-':case ')':case '\n':ch='>';break;case '*':case '/':case'^':case '(':ch='<';break;}break;}case '*':case '/':{if(ch2=='('||ch2=='^')ch='<';elsech='>';break;}case'^':{if(ch2=='(')ch='<';elsech='>';break;}case'(':{if(ch2==')')ch='=';elsech='<';break;}case ')':{ch='>';break;}case '\n':{if(ch2=='\n')ch='=';elsech='<';break;}}return(ch);}template <typename T>int EvaluateExpression(){char c,theta; int a,b,answer; T:OPTR,OPND;initStack(OPTR); push (OPTR, '\n');initStack(OPND); c=getchar( );while(c!='\n' || GetTop(OPTR)!= '\n' ) { //边输入边处理if (!In(c, OP)) { push(OPND, c); c=getchar( ); }// 不是运算符则进栈，In(c, OP)判断c是否是运算符elseswitch( Precede(GetTop(OPTR), c) ){case <: // 新输入的算符c优先级高，c进栈push(OPTR, c); c=getchar( ); break;case =: // 脱括号并接收下一字符pop(OPTR, x); c=getchar( ); break;case >: // 新输入的算符c优先级低(栈顶算符优先级高)// 出栈并将运算结果入栈OPNDpop(OPTR, theta);pop(OPND, b); Pop(OPND, a);push(OPND, Operate(a, theta, b) );break;} // switch} // whileanswer= GetTop(OPND);cout<<answer <<endl;return 0;}template <typename T>int main(){EvaluateExpression();return 0;}此程序运行过程中，编译没错，可一到连接就出现这个问题：1 unresolved externals！再三思考，我放弃了这个方案，通过百度搜索，我找到一个以#结束，不能乘方运算，没有详细错误提示的程序，其思路与老师的方案大致相同，只不过采用了数组的形式，不过都对中缀表达式的长度没有确定的要求。
中缀算术表达式的轻量化求值算法
中缀算术表达式的轻量化求值算法
白宇;郭显娥
【期刊名称】《计算机应用》
【年(卷),期】2013(33)11
【摘要】针对当前中缀算术表达式求值算法笨重或者复杂的问题,提出了一种轻量化的中缀算术表达式求值算法.该算法基于逆向拆分中缀算术表达式的思路,使用递归解析的方法,等价于中缀算术表达式的构造二叉树表示.实验结果表明,该算法与传统逆波兰表达式(RPN)转换、求值算法相比,该算法无需做逆波兰表达式转换,无需人工栈辅助,实现代码量仅有其1/6,而效率仅下降6.9％.与W3Eval算法相比,该算法无需符号转置表,支持算符自定义或重定义,实现代码量不到其1/2.该算法实现代价低,适用于Web应用的Browser端,及嵌入式应用等轻量化应用场合.
【总页数】4页(P3163-3166)
【作者】白宇;郭显娥
【作者单位】山西大同大学数学与计算机科学学院,山西大同037009;山西大同大学数学与计算机科学学院,山西大同037009
【正文语种】中文
【中图分类】TP311.12
【相关文献】
1.基于栈结构的算术表达式求值算法研究 [J], 兰美辉;杨平
2.浮点型数据算术表达式求值算法研究与实现 [J], 杨爱丽
3.中缀及后缀算术表达式在运算中的应用研究 [J], 郭萌萌;许永昌
4.算术表达式求值算法实现的难点剖析 [J], 王淑礼;王新霞
5.栈类模板在算术表达式求值算法中的应用 [J], 张静
因版权原因，仅展示原文概要，查看原文内容请购买。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
合。
关键词 ： 轻量化 算法 ； 中缀 算术表 达式 ； 逆 向拆 分 ； 逆波 兰表 达式； Ｗ３ Ｅ ｖ ａ ｌ
中 图分 类 号 ： Ｔ Ｐ ３ １ １ ． １ ２ 文献标志码 ： Ａ
Ｊ ｏ ｕ ｒ ｎ ａ ｌ ｏ ｆ Ｃ ｏ ｍｐ ｕ ｔ ｅ ｒ Ａ ｐ ｐ ｌ ｉ ｃ ａ ｔ ｉ ｏ ｎ ｓ
Ｉ Ｓ Ｓ Ｎ １ ０ ０ １ — ９ ０ ８ １
２ ０ １ ３ — １ １ ． ０１
计 算 机 应 用， ２ ０ １ ３ ， ３ ３ （ １ １ ） ： ３ １ ６ ３— ３ １ ６ ６ 文章编号 ： １ ０ ０ １ ・ ９ ０ ８ １ （ ２ ０ １ ３ ） １ １ — ３ １ ６ ３ — ０ ４
ｔ ｒ ｅ ｅ ．Ｔ ｈ ｅ ｅ ｘ ｐ ｅ ｉ ｒ ｍ ｅ ｎ ｔ ｌ ａ ｒ ｅ ｓ ｕ ｌ ｔ ｓ ｓ ｈ ｏ ｗ ｔ ｈ ａ ｔ ｃ ｏ ｍ ｐ ａ ｒ ｅ ｄ ｗ ｉ ｔ ｈ ｔ ｈ ｅ ａ ｌ ｇ ｏ ｉ ｒ ｔ ｈ ｍ ｏ ｆ ｔ ｒ ａ ｄ ｉ ｔ ｉ ｏ ｎ ｌ ａ Ｒ ｅ ｖ ｅ ｒ ｓ ｅ Ｐ ｏ ｌ ｉ ｓ ｈ Ｎ ｏ ｔ ａ ｔ ｉ ｏ ｎ（ Ｒ Ｐ Ｎ）
ｔ ｒ ａ ｎ ｓ ｆ ｏ ｒ ｍａ ｔ ｉ ｏ ｎ ａ ｎ ｄ ｅ ｖ ｌｕ ａ ａ ｔ ｉ ｏ ｎ ，ｔ ｈ ｅ ｐ ｒ ｏ ｐ ｏ ｓ ｅ ｄ ａ ｌ ｇ ｏ ｉ ｒ ｔ ｈ ｍ ｄ ｉ ｄ ｎ ｏ ｔ ｎ ｅ ｅ ｄ ｔ ｏ ｄ ｏ ＲＰ Ｎ ｔ ｒ ａ ｎ ｓ ｆ ｏ ｍ ｒ ａ ｎ ｄ ａ ｓ ｓ ｉ ｓ ｔ ｏ ｆ ｈ ａ ｎ ｄ — ｏ ｐ ｅ ｒ ａ ｔ ｅ ｄ ｓ ｔ ａ ｃ ｋ ，ｉ ｔ ｓ ａ ｍｏ ｕ ｎ ｔ ｏ ｆ ｃ ｏ ｄ ｅ ｗａ ｓ ｏ ｎ ｌ ｙ １ ／ ６ ｏ ｆ ＲＰ Ｎ ｔ ｒ ａ ｎ ｓ ｆ ｏ ｍａ ｒ ｔ ｉ ｏ ｎ ．ａ ｎ ｄ ｔ ｈ ｅ ｅ ｆ ｉ ｆ ｃ ｉ ｅ ｎ ｃ ｙ ｄ ｅ ｃ ｌ ｉ ｎ ｅ ｄ ｂ ｙ ｏ ｎ ｌ ｙ ６ ． ９ ％ ．Ｔ ｏ ｃ ｏ ｍｐ ａ ｒ ｅ ｄ ｗ ｉ ｔ ｈ Ｗ３ Ｅ ｖ ａ ｌ ａ ｌ ｇ ｏ ｉ ｒ ｔ ｈ ｍ，ｉ ｔ ｄ ｉ ｄ ｎ ｏ ｔ ｎ ｅ ｅ ｄ ｔ ｏ ｕ ｓ ｅ ｔ ｒ ａ ｎ ｓ ｐ ｏ ｓ ｅ ｔ ａ ｂ ｌ ｅ ｏ ｆ ｓ ｙ ｍｂ ｏ ｌ ，ｓ ｕ ｐ ｐ ｏ ｒ ｔ ｉ ｎ ｇ ｄ ｅ ｉ ｆ ｎ ｅ ｏ ｒ ｒ ｅ ｄ ｅ ｉ ｆ ｎ ｅ ｏ ｆ ｏ ｐ ｅ ｒ ａ ｔ ｏ ｒ ，ａ ｎｄ ｉ ｔ ｓ ａ ｍｏ ｕ ｎ ｔ ｏ ｆ ｃ ｏ ｄ ｅ ｗ ａ ｓ ｌ ｅ ｓ ｓ ｔ ｈ ａ ｎ ｈ ａ ｌ ｆ ｏ ｆ Ｗ３ Ｅ ｖ ａ ｌ ａ ｌ ｇ ｏ ｉ ｒ ｔ ｈ ｍ．Ｔ ｈ ｅ ｌｇ ａ ｏ ｉ ｒ ｔ ｈ ｍ ｄ ｅ ｍａ ｎ ｄ ｓ ｌ ｏ ｗ— ｃ ｏ ｓ ｔ ｉ ｍｐ ｌ ｅ ｍｅ ｎ ｔ ａ ｔ ｉ ｏ ｎ ，ａ ｎｄ ｉ ｔ ｉ ｓ ｓ ｕ ｉ ｔ ｂｌ ａ ｅ ｆ ｏ ｒ ｌ ｉ ｇ ｈ ｔ ｗｅ ｉ ｇ ｈ ｔ ａ ｐ ｐ ｌ ｉ ｃ ａ ｔ ｉ ｏ ｎ ｓ ｓ ｕ ｃ ｈ ａ ｓ ｂ ｒ ｏ ｗｓ ｅ ｒ — ｓ ｉ ｄ ｅ ｏ ｆ Ｗｅ ｂ ａ ｐ ｐ ｌ ｉ ｃ ａ ｔ ｉ ｏ ｎ ｓ ａ ｎ ｄ ｅ ｍｂ ｅ ｄ ｄ ｅ ｄ ａ ｐ ｐ ｌ ｉ ｃ ａ ｔ ｉ ｏ ｎ ｓ ．
Ａｂ ｓ ｔ ｒ ａ ｃ ｔ ：Ｃ ｏ ｎ ｃ ｅ ｒ ｎ ｉ ｎ ｇ ｔ ｈ ｅ ｂ ｕ ｌ ｋ ｙ ｏ ｒ ｃ ｏ ｍｐ ｌ ｅ ｘ ｃ ｕ ｒ ｒ ｅ ｎ ｔ ｅ ｖ ａ ｌ ｕ ａ ｔ ｉ ｏ ｎ ａ ｌ ｇ ｏ ｉ ｒ ｔ ｈ ｍ ｏ ｆ ｉ ｎ ｆ ｉ ｘ ａ ｉｔ ｒ ｈ ｍｅ ｔ ｉ ｃ ｅ ｘ ｐ ｒ ｅ ｓ ｓ ｉ ｏ ｎ ，ａ ｌ ｉ ｇ ｈ ｔ ｗｅ ｉ ｇ ｈ ｔ ｅ ｖ ｌｕ ａ ａ ｔ ｉ ｏ ｎ ａ ｌ ｇ ｏ ｉｔ ｒ ｈ ｍ ｆ ｏ ｒ ｉ ｎ ｉ ｆ ｘ ａ ｒ ｉ ｔ ｈ ｍｅ ｔ ｉ ｃ ｅ ｘ ｐ ｒ ｅ ｓ ｓ ｉ ｏ ｎ ｗａ ｓ ｐ ｒ ｏ ｐ ｏ ｓ ｅ ｄ ．Ｔ ｈ ｅ ａ ｌ ｇ ｏ ｒ ｉ ｔ ｈ ｍ ｗａ ｓ ｂ ａ ｓ ｅ ｄ ｏ ｎ ｔ ｈ ｅ ｉ ｄ ｅ ａ ｏ ｆ ｔ ｈ ｅ ｒ ｅ ｖ ｅ ｒ ｓ ｅ ｓ ｐ ｌ ｉ ｔ ｉ ｉｘ ｆ ｎ ａ ｉ ｒ ｔ ｈ ｍｅ ｔ ｉ ｃ ｅ ｘ ｐ ｒ ｅ ｓ ｓ ｉ ｏ ｎ ，ｕ ｓ ｉ ｎ ｇ ｔ ｈ ｅ ｍｅ ｔ ｈ ｏ ｄ ｏ ｆ ｒ ｅ ｃ ｕ ｒ ｓ ｉ ｖ ｅ ａ ｎ ａ ｌ ｙ ｓ ｉ ｓ ，ｅ ｑ ｕ ｉ ｖ ｌｅ ａ ｎ ｔ ｔ ｏ ｉ ｉ ｘ ｆ ｎ ａ ｉ ｒ ｔ ｈ ｍｅ ｔ ｉ ｃ ｅ ｘ ｐ ｒ ｅ ｓ ｓ ｉ ｏ ｎ ｓ ｏ ｆ ｃ ｏ ｎ ｓ ｔ ｒ ｕ ｃ ｔ ｉ ｎ ｇ ｂ ｉ ｎ ａ ｒ ｙ
Ｌｉ ｇ ｈｔ ｗｅ ｉ ｇ ｈｔ ｅ ｖ ａ ｌ ｕ ａ ｔ ｉ ｏ ｎ ａ ｌ ｇ ｏ ｒ ｉ ｔ ｈ ｍ ｆ ｏ ｒ ｉ ｎｆ ｉｘ ａ ｒ ｉ ｔ ｈｍ ｅ ｔ ｉ ｃ ｅ ｘ ｐ ｒ ｅ ｓ ｓ ｉ ｏ ｎ
ＢＡＩ Ｙｕ ， ＧＵＯ Ｘｉ ａ ｎ ’ ｅ
（ Ｓ ｃ ｈ ｏ ｏ ｌ ｏ ｆ Ｍａ ｔ ｈ ｅ ｍａ ｔ ｉ ｃ ｓ ａ ｎ ｄ Ｃ ｏ ｍ ｐ ｕ ｔ ｅ ｒ Ｓ ｃ ｉ ｅ ｎ ｃ ｅ ，Ｓ ｈ ａ ｎ ｘ ｉ Ｄ ａ ｔ ｏ ｎ ｇ Ｕ ｎ ｉ ｖ ｅ ｒ ｓ ｉ ｔ ｙ ，Ｄ ａ ｔ ｏ ｎ ｇ Ｓ ｈ ａ ｎ ｘ ｉ ０ ３ ７ ０ ０ ９ ，Ｃ ｈ ｉ ｎ ａ ）
白 宇 ， 郭显娥
（ 山西大同大学 数学 与计算 机科学学院， 山西 大同 ０ ３ ７ ０ ０ ９ ）
（ 通信作 者电子邮箱 ｍ ｅ ｎ）
摘
要： 针 对 当前 中缀算术表 达式求值算 法笨 重或者 复杂 的问题 ， 提 出了一种轻量 化的 中缀算术表 达式 求值 算
Ｃ０ ＤＥＮ Ｊ ＹＩ Ｉ ＤＵ
ｈ ｔ ｔ ｐ ： ／ ／ ｗ ｗ ｗ ． ｊ ｏ ｃ ａ ． ｃ ｎ
ｄ ｏ ｉ ： １ ０ ． １ １ ７ ７ ２ ／ ｊ ． ｉ ｓ ｓ ｎ ． １ ０ ０ １ — ９ ０ ８ １ ． ２ ０ １ ３ ． １ １ ． ３ １ ６ ３
中缀 算 术 表 达 式 的 轻 量 化 求 值 算 法
法。该算法基 于逆 向拆分 中缀算术表达 式的思路 ， 使 用递归解析 的方 法， 等价 于 中缀算 术表 达式 的构造二叉树表 示。
实验结果表 明， 该算 法与传 统逆波兰表达式 （ Ｒ Ｐ Ｎ） 转换 、 求值 算法相 比， 该算 法无 需做逆 波兰表达 式转换 ， 无 需人 工
栈辅助 ， 实现代码量仅 有其 １ ／ ６ ， 而效率仅 下降 ６ ． ９ ％ 。与 Ｗ３ Ｅ ｖ ａ ｌ 算 法相 比， 该 算法无需符号转置表 ， 支持算符 自定 义