逆波兰表达式代码

合集下载

c语言逆波兰表

c语言逆波兰表

c语言逆波兰表C语言逆波兰表达式简介一、什么是逆波兰表达式逆波兰表达式,也被称为后缀表达式,是一种不需要括号来标识操作符优先级的数学表达式表示方法。

在逆波兰表达式中,操作符位于操作数之后,因此也被称为后缀表达式。

二、逆波兰表达式的优势1. 不需要括号,减少了人为输入错误的概率。

2. 操作符的位置固定,使得计算机在计算逆波兰表达式时更加简单高效。

3. 逆波兰表达式可以通过栈来实现计算,使得计算逻辑更加清晰。

三、逆波兰表达式的转换将常见的中缀表达式转换为逆波兰表达式有两种方法:中缀转后缀法和中缀转前缀法。

这里我们主要介绍中缀转后缀的方法。

1. 创建一个空栈和一个空字符串作为结果。

2. 从左到右遍历中缀表达式的每个字符。

3. 如果当前字符是操作数,则直接将其添加到结果字符串中。

4. 如果当前字符是操作符,则判断其与栈顶操作符的优先级:a. 如果栈为空,则直接将操作符入栈。

b. 如果栈不为空,且栈顶操作符的优先级大于等于当前操作符,则将栈顶操作符弹出并添加到结果字符串中,直到栈为空或栈顶操作符的优先级小于当前操作符,然后将当前操作符入栈。

5. 如果当前字符是左括号"(",则直接入栈。

6. 如果当前字符是右括号")",则将栈中的操作符弹出并添加到结果字符串中,直到遇到左括号为止。

此时将左括号弹出,但不添加到结果字符串中。

7. 遍历完中缀表达式后,将栈中剩余的操作符依次弹出并添加到结果字符串中。

四、逆波兰表达式的计算计算逆波兰表达式可以利用栈来实现。

具体步骤如下:1. 创建一个空栈。

2. 从左到右遍历逆波兰表达式的每个字符。

3. 如果当前字符是操作数,则将其转换为数值并入栈。

4. 如果当前字符是操作符,则从栈中弹出两个操作数进行计算,并将计算结果入栈。

5. 遍历完逆波兰表达式后,栈中只剩下一个元素,即为最终的计算结果。

五、逆波兰表达式的应用逆波兰表达式在编程语言解析、数学计算和计算器等领域有着广泛的应用。

C语言之逆波兰表达式完整代码(附算法)

C语言之逆波兰表达式完整代码(附算法)

C语言课程设计之逆波兰表达式//逆波兰表达式(后缀表达式)reverse polish notation//程序实现的功能是将中缀表达式转变为后缀表达式,再求出其值//主要运用的知识点有:isdigit函数,pow函数,system("cls")函数,堆栈,格式的强制转换#include<stdio.h>#include<ctype.h>#include<stdlib.h>#include<math.h>void shift( char notation[]); //中缀表达式转换为后缀表达式的转换函数float calculate(float a[][2],int k); //计算后缀表达式int judge(char notation[]); //判断输入的中缀表达式是否符合要求int grade(char a); //返回运算符的等级void display(float a[][2],int k); //在屏幕上显示后缀表达式//主函数void main(){char notation [100];char choice;do{printf("请输入正确的中缀表达式:\n");printf("例如:2*3+4/3-(2+1)\n");scanf("%s",&notation);if(judge(notation)){shift(notation);}elseprintf("你的表达式有错误,请仔细检查!\n");fflush(stdin);printf("\n你是否需要继续计算(是输入Y/y,否输入其他任意键)\n");scanf("%c",&choice);getchar();system("cls");}while(choice=='Y'||choice=='y');printf("\n程序结束,谢谢使用!\n");}//判定函数int judge(char notation[]){int i,m,num=1,p1=0,p2=0;for(i=0;notation[i]!='\0';i++) //排除表达式外的字符{if(notation[i]!='('&&notation[i]!=')'&&notation[i]!='+'&&notation[i]!='-'&&notation[i]!='*'&&notation[i]!='/'&&!isdigit(notation[i])&&notation[i]!='.') {num=0;return num;}}if(notation[0]=='*'||notation[0]=='/'||notation[0]==')'||notation[0]=='.') //排除第一个字符为*,/,),.{num=0;return num;}for(i=0;notation[i]!='\0';i++) //排除'+','-','*','/','.'之间的连续出现以及'+','-','*','/','.'后面直接加')'{if(notation[i]!='('&&notation[i]!=')'&&!isdigit(notation[i])){if(notation[i+1]!='('&&!isdigit(notation[i+1])){num=0;return num;}}if(notation[i]=='('&&(notation[i+1]==')'||notation[i+1]=='.'||notation[i+1]=='*'||notation[i+ 1]=='/')){ //排除'('和')','.','*','/'一起连用num=0;return num;}if(notation[i]==')'&&(notation[i+1]=='('||notation[i+1]=='.'))//排除')'和'(','.'一起连用{num=0;return num;}}for(i=0;notation[i]!='\0';i++) //小数位不得超过4位{if(notation[i]=='.'&&notation[i+1]!='\0'&&notation[i+2]!='\0'&&notation[i+3]!='\0'&&notation[i+4]!='\0'&&notation[i+5]!='\0'){if(isdigit(notation[i+1])&&isdigit(notation[i+2])&&isdigit(notation[i+3])&&isdigit(notation[i+ 4])&&isdigit(notation[i+5])){num=0;return num;}}}for(i=0;notation[i]!='\0';i++) //排除一个小数中有两个小数点的情况{if(notation[i]=='.'){i++;while(isdigit(notation[i])){i++;}if(notation[i]=='.'){num=0;return 0;}}}for(i=0;notation[i]!='\0';i++) //排除')'后面不可以直接跟数字以及'('前面不可以加数字{if(notation[i]==')'&&isdigit(notation[i+1])){num=0;return num;}if(isdigit(notation[i])&&notation[i+1]=='(' ){num=0;return num;}}for(i=0;notation[i]!='\0';i++) //约束数字的位数一共最多为七位{if(isdigit(notation[i])){m=0; //用来计数,数字的位数为7while(isdigit(notation[i])||notation[i]=='.'){i++;m++;if(notation[i]=='.'){m--;}}if(m>7){num=0;return num;}}}for(i=0;notation[i]!='\0';i++) //'('与')'需要配对存在{if(notation[i]=='(')p1++;if(notation[i]==')')p2++;if(p1!=p2){num=0;return num;}}return num;}//转换函数void shift( char notation[]){char s1[100];s1[0]='#';float s2[100][2]; //第一维放后缀表达式的元素,第二维表示小数点的位数以及是否是运算符int i=0,j=1,k=0,t=0;float sum,num1=0,num2=0; //num1为存储整数位num2为存储小数位while(notation[i]!='\0'){if(i==0&&notation[i]=='+') //第一位为正号的情况{if(isdigit(notation[++i])){num1=0; //整数部分while(isdigit(notation[i])){num1=num1*10+(notation[i]-'0'); //notation[i]-'0'可以将字符转换为整数0~9i++;}num2=0; //小数部分t=0;if(notation[i]=='.'){i++;while(isdigit(notation[i])){num2=float (num2+pow(0.1,++t)*(notation[i]-'0'));i++;}}s2[k++][0]=float(num1+num2);s2[k-1][1]=float(t);}}if(i==0&&notation[i]=='-') //第一位为负号的情况,代码与正号类似{if(isdigit(notation[++i])){num1=0;while(isdigit(notation[i])){num1=(-1)*num1*10+(-1)*(notation[i]-'0');i++;}num2=0;t=0;if(notation[i]=='.'){i++;while(isdigit(notation[i])){num2=float(num2+(-1)*pow(0.1,++t)*(notation[i]-'0'));i++;}}s2[k++][0]=float(num1+num2);s2[k-1][1]=float(t);}}if(isdigit(notation[i])) //当前字符为数字的情况与为正号的情况一样{num1=0;while(isdigit(notation[i])){num1=num1*10+(notation[i]-'0');i++;}num2=0;t=0;if(notation[i]=='.'){i++;while(isdigit(notation[i])){num2=float(num2+pow(0.1,++t)*(notation[i]-'0'));i++;}}s2[k++][0]=float(num1+num2);s2[k-1][1]=float(t);}if(notation[i]=='+'||notation[i]=='-'||notation[i]=='*'||notation[i]=='/'){ //当前的字符为操作符时,如果s1的站定为'('则将字符直接送入s1if(s1[j-1]=='('){s1[j++]=notation[i++];}}if(notation[i]=='+'||notation[i]=='-'||notation[i]=='*'||notation[i]=='/'){ //当前字符为操作符时的普通的情况if(grade(notation[i])>grade(s1[j-1])){s1[j++]=notation[i++];}else{s2[k++][0]=s1[--j];s2[k-1][1]=-1;s1[j++]=notation[i++];}}if(notation[i]=='(') //当前字符为'('的情况{s1[j++]=notation[i++];if(notation[i]=='+') //'('后跟正号的情况{if(isdigit(notation[++i])){num1=0;while(isdigit(notation[i])){num1=num1*10+(notation[i]-'0');i++;}num2=0;t=0;if(notation[i]=='.'){i++;while(isdigit(notation[i])){num2=float(num2+pow(0.1,++t)*(notation[i]-'0'));i++;}}s2[k++][0]=float(num1+num2);s2[k-1][1]=float(t);}}if(notation[i]=='-') //'('后跟负号的情况{if(isdigit(notation[++i])){num1=0;while(isdigit(notation[i])){num1=float((-1)*num1*10+(-1)*(notation[i]-'0'));i++;}num2=0;t=0;if(notation[i]=='.'){i++;while(isdigit(notation[i])){num2=float(num2+(-1)*pow(0.1,++t)*(notation[i]-'0'));i++;}}s2[k++][0]=float(num1+num2);s2[k-1][1]=float(t);}}}if(notation[i]==')') //当前字符为')'的情况{while(s1[--j]!='('){s2[k++][0]=s1[j];s2[k-1][1]=-1;}i++;}}while(j>0&&s1[--j]!='#') //依次将s1中的除了'#'外的所有操作符出栈,相当于最后的扫尾工作{s2[k++][0]=s1[j];s2[k-1][1]=-1;}printf("\n后缀表达式(逆波兰表达式):\n");display(s2,k-1);printf("\n表达式的值为:\n");sum=calculate(s2,k-1);printf("%7.4f",sum);}//计算函数float calculate(float a[][2],int k){int i,t=0,j=k;float b[100][2],c[100];for(i=k;i>=0;i--){b[i][0]=a[k-i][0];b[i][1]=a[k-i][1];}i=k;while(j>=0){if(b[i][1]!=-1){c[t]=float (b[i][0]);j--;i--;t++;}if(b[i][1]==-1) //每当遇到一个运算符则将栈最上面的两个数出栈进行运算,然后再入栈{if(int(b[i][0])=='+'){c[t-2]=float (c[t-2]+c[t-1]);}if(int(b[i][0])=='-'){c[t-2]=float (c[t-2]-c[t-1]);}if(int(b[i][0])=='*'){c[t-2]=float (c[t-2]*c[t-1]);}if(int(b[i][0])=='/'){c[t-2]= float (c[t-2]/c[t-1]);}j--;i--;t--;}}return c[0]; //运算到最后,栈中的元素即为结果}//等级函数int grade(char a) //按照运算符的优先级{if(a=='#')return 0;if(a=='(')return 1;if(a=='-'||a=='+')return 2;if(a=='*'||a=='/')return 3;if(a==')')return 4;elsereturn 5;}//显示函数void display(float a[][2],int k){int i;for(i=0;i<=k;i++){if(a[i][1]==0)printf(" %d",int(a[i][0]));if(a[i][1]==1)printf(" %7.1f",a[i][0]);if(a[i][1]==2)printf(" %7.2f",a[i][0]);if(a[i][1]==3)printf(" %7.3f",a[i][0]);if(a[i][1]==4)printf(" %7.4f",a[i][0]);if(a[i][1]==-1)printf(" %c",int (a[i][0]));}}算法实现一个表达式E的后缀形式可以如下定义:(1)如果E是一个变量或常量,则E的后缀式是E本身。

逆波兰运算c语言实现

逆波兰运算c语言实现

逆波兰运算c语言实现以逆波兰运算C语言实现为标题逆波兰表达式(Reverse Polish Notation,简称RPN)是一种数学表达式的书写方式,也是一种计算机科学中常用的运算方式。

在逆波兰表达式中,操作符位于操作数的后面,这样可以避免使用括号,使得表达式更加简洁明了。

本文将介绍如何使用C语言实现逆波兰运算。

1. 逆波兰表达式的基本概念逆波兰表达式的基本原则是将操作符放在操作数的后面,以此来表示运算顺序。

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

在逆波兰表达式中,每个操作数和操作符之间都用空格分隔开。

2. 实现逆波兰表达式的算法为了实现逆波兰表达式的计算,我们可以使用栈来存储操作数和操作符。

遍历逆波兰表达式的每一个元素,如果是操作数,就将其入栈;如果是操作符,就从栈中弹出两个操作数进行运算,并将结果再次入栈。

最后,栈中剩下的元素即为最终的计算结果。

3. C语言实现逆波兰表达式的代码下面是一个简单的C语言实现逆波兰表达式的代码示例:```c#include <stdio.h>#include <stdlib.h>#include <string.h>#define MAX_STACK_SIZE 100typedef struct {int top;int stack[MAX_STACK_SIZE];} Stack;void push(Stack *s, int value) {if (s->top < MAX_STACK_SIZE) { s->stack[s->top++] = value; } else {printf("Stack Overflow\n"); exit(1);}}int pop(Stack *s) {if (s->top > 0) {return s->stack[--s->top]; } else {printf("Stack Underflow\n");exit(1);}}int calculate(int a, int b, char operator) { switch (operator) {case '+':return a + b;case '-':return a - b;case '*':return a * b;case '/':return a / b;default:printf("Invalid Operator\n");exit(1);}}int evaluateRPN(char *rpn) {Stack s;int len = strlen(rpn);for (int i = 0; i < len; i++) {if (isdigit(rpn[i])) {push(&s, rpn[i] - '0');} else if (rpn[i] == ' ') {continue;} else {int b = pop(&s);int a = pop(&s);int result = calculate(a, b, rpn[i]); push(&s, result);}}return pop(&s);}int main() {char rpn[] = "3 4 +";int result = evaluateRPN(rpn);printf("The result is: %d\n", result);}```4. 运行结果分析以上代码中的逆波兰表达式为"3 4 +",表示的是3加4。

逆波兰表达式

逆波兰表达式

逆波兰表达式逆波兰表达式题⼲正常的表达式称为中缀表达式,运算符在中间,主要是给⼈阅读的,机器求解并不⽅便。

例如:3 + 5 * (2 + 6) - 1⽽且,常常需要⽤括号来改变运算次序。

相反,如果使⽤逆波兰表达式(前缀表达式)表⽰,上⾯的算式则表⽰为:- + 3 * 5 + 2 6 1不再需要括号,机器可以⽤递归的⽅法很⽅便地求解。

为了简便,我们假设:只有 + - * 三种运算符每个运算数都是⼀个⼩于10的⾮负整数下⾯的程序对⼀个逆波兰表⽰串进⾏求值。

其返回值为⼀个结构:其中第⼀元素表⽰求值结果,第⼆个元素表⽰它已解析的字符数。

public static int[] evaluate(String x){if(x.length() == 0) return new int[]{0,0};char c = x.charAt(0);if (c >= '0' && c <= '9')return new int[]{c - '0', 1};int[] v1 = evaluate(x.substring(1));int[] v2 = __________________________________;//填空位置int v = Integer.MAX_VALUE;if (c == '+') v = v1[0] + v2[0];if (c == '*') v = v1[0] * v2[0];if (c == '-') v = v1[0] - v2[0];return new int[]{v, 1 + v1[1] + v2[1]};}代码public class _06逆波兰表达式 {// int[]数组中// 其中第⼀元素表⽰求值结果,第⼆个元素表⽰它已解析的字符数。

public static int[] evaluate(String x){if(x.length() == 0) return new int[]{0,0}; //char c = x.charAt(0); //取到⾸字符if (c >= '0' && c <= '9') //如果是数字return new int[]{c - '0', 1};// 如果是下⾯的情况,说明是字符,虽然此处没有else但是所表达的意思就是上⾯if之外的情况,因为上⾯的if没有执⾏的话才能够运⾏到下⼀⾏代码int[] v1 = evaluate(x.substring(1));//这⾥是除去第⼀个字符不要的其他部分,第⼀个字符是运算符int[] v2 = evaluate(x.substring(1+v1[1]));//填空位置,猜测是截取上⼀次没有处理到的部分// v1[1]处理v1消耗的字符数量//int v = Integer.MAX_VALUE;if (c == '+') v = v1[0] + v2[0];if (c == '*') v = v1[0] * v2[0];if (c == '-') v = v1[0] - v2[0];return new int[]{v, 1 + v1[1] + v2[1]};}public static void main(String[] args) {// TODO Auto-generated method stubSystem.out.println(evaluate("-+3*5+261")[0]);}}总结1.观察代码,也是从第⼀个字符开始:如果是数字,那么直接返回;如果不是,说明遇到了⼀个操作符,那么v1从这个操作符的后⼀位字符开始递归,直到遇到数字返回;然后v2再进⾏⼀些操作;最后把v1和v2对应的值对于回溯时最近的那个操作符进⾏运算。

逆波兰表达式

逆波兰表达式

基本思路:
扫描后缀算术表达式字符串,每次从字符串中读取一个字符, 读到空格不做任何处理,若读到运算符,则表明它的两个操 作数已经在栈中,否则读到的字符必为数字,应把它转换为 一个正整数存入一个变量中,然后把计算或转换得到的正整 数(即该变量的值)压入栈中,依次扫描每个字符并进行上述 处理,直到遇到结束符,表明后缀表达式计算完成,最终结 果保存在栈中,并且栈中只有这一个值。
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.掌握FirstVt和LastVt集合的求法有算符优先关系表的求法3.掌握利用算符优先分析法完成中缀表达式到逆波兰式的转化二.实验内容及要求将非后缀式用来表示的算术表达式转换为用逆波兰式来表示的算术表达式,并计算用逆波兰式来表示的算术表达式的值。

程序输入/输出示例:输出的格式如下:(1)(2)输入一以#结束的中缀表达式(包括+—*/()数字#)(3)(4)逆波兰式备注:(1)在生成的逆波兰式中如果两个数相连则用&分隔,如28和68,中间用&分隔;串。

注意:1.表达式中允许使用运算符(+-*/)、分割符(括号)、数字,结束符#;2.如果遇到错误的表达式,应输出错误提示信息(该信息越详细越好);3.对学有余力的同学,测试用的表达式事先放在文本文件中,一行存放一个表达式,同时以分号分割。

同时将预期的输出结果写在另一个文本文件中,以便和输出进行对照;三.实验过程1、逆波兰式定义将运算对象写在前面,而把运算符号写在后面。

用这种表示法表示的表达式也称做后缀式。

逆波兰式的特点在于运算对象顺序不变,运算符号位置反映运算顺序。

采用逆波兰式可以很好的表示简单算术表达式,其优点在于易于计算机处理表达式。

2、产生逆波兰式的前提中缀算术表达式3、逆波兰式生成的实验设计思想及算法(1)首先构造一个运算符栈,此运算符在栈内遵循越往栈顶优先级越高的原则。

(2)读入一个用中缀表示的简单算术表达式,为方便起见,设该简单算术表达式的右端多加上了优先级最低的特殊符号“#”。

(3)从左至右扫描该算术表达式,从第一个字符开始判断,如果该字符是数字,则分析到该数字串的结束并将该数字串直接输出。

(4)如果不是数字,该字符则是运算符,此时需比较优先关系。

做法如下:将该字符与运算符栈顶的运算符的优先关系相比较。

如果,该字符优先关系高于此运算符栈顶的运算符,则将该运算符入栈。

c++逆波兰表达式递归

c++逆波兰表达式递归

C++逆波兰表达式递归逆波兰表达式,也叫后缀表达式,是一种比较常用的表达式表示方法。

逆波兰表达式将操作符放在操作数的后面,因此不需要考虑运算符的优先级和括号的问题。

例如,正常的中缀表达式"1+2*3"在逆波兰表达式中就可以表示为"1 2 3 * +"。

在这篇文章中,我们将会介绍如何用递归的方式来实现C++逆波兰表达式的计算。

1.递归函数我们首先需要定义一个递归函数来计算逆波兰表达式。

这个递归函数需要接受一个字符串(逆波兰表达式)作为参数,并返回一个整数(表达式的计算结果)。

递归函数的整体框架如下:int evaluate(string expression) {// 在这里实现递归函数}我们需要在函数中实现递归计算逆波兰表达式的功能。

2.处理长度为1的表达式递归函数的第一步是检查表达式的长度。

如果表达式的长度为1,则表明该表达式是操作数,可以直接返回该值。

我们可以通过下面的代码来实现这一步:if (expression.length() == 1) {return stoi(expression); // 将字符串转换为整数}在这里,我们使用了stoi函数将一个字符串转换为整数。

由于表达式的长度为1,我们可以将该字符串作为整数直接返回。

3.处理长度大于1的表达式如果表达式的长度大于1,那么该表达式一定是一个操作符和两个操作数的组合,此时我们需要找到该操作符,并对两个操作数进行计算。

我们可以通过下面的代码来找到操作符:char op = expression.back(); // 找到操作符expression.pop_back(); // 删掉操作符在这里,我们使用了back()函数来获取字符串的最后一个字符,也就是操作符。

同时,我们使用了pop_back()函数来删掉该操作符,这样原来的字符串中就只剩下操作数了。

接下来,我们需要找到这两个操作数。

找到操作数的方法与找到操作符的方法类似。

python实现逆波兰计算表达式的代码

python实现逆波兰计算表达式的代码

python实现逆波兰计算表达式的代码如下资料是关于python实现逆波兰计算表达式的代码。

symbol_priority = {}symbol_priority[0] = ['#']symbol_priority[1] = ['(']symbol_priority[2] = ['+', '-']symbol_priority[4] = [')']def comparePriority(symbol, RPN_stack, symbol_stack):'''Compare priority between two symbols'''global symbol_priorityif len(symbol_stack) > 0:symbol_pop = symbol_stack.pop()else:returnfor list in symbol_priority.values():if (symbol in list) and (symbol_pop in list):'''same priority'''symbol_stack.append(symbol_pop)symbol_stack.append(symbol)returnelif symbol in list:'''symbol is smaller'''RPN_stack.append(symbol_pop)#recusion callcomparePriority(symbol, RPN_stack, symbol_stack)returnelif symbol_pop in list:'''symbol is bigger'''symbol_stack.append(symbol_pop)symbol_stack.append(symbol)returnelse:continuesymbol_stack.append(symbol_pop)returndef scanEveryone(input_string, RPN_stack, symbol_stack):for ch in input_string:if ch.isdigit():RPN_stack.append(ch)else:if len(symbol_stack) > 0:if ch == '(':symbol_stack.append(ch)elif ch == ')':while True:symbol_pop = symbol_stack.pop()if symbol_pop == '(':breakelse:RPN_stack.append(symbol_pop)else:comparePriority(ch, RPN_stack, symbol_stack)else:symbol_stack.append(ch)def scanInput(RPN_stack, symbol_stack):input_string = raw_input()input_string += '#'scanEveryone(input_string, RPN_stack, symbol_stack)def calRPN(RPN_stack):value_stack = []RPN_stack.append('#')for value in RPN_stack:if value == '#':return value_stack.pop()breakif value.isdigit():value_stack.append(value)else:right_value = value_stack.pop()left_value = value_stack.pop()cal_string = left_value + value + right_valuevalue_stack.append(str(eval(cal_string)))def main():RPN_stack = []symbol_stack = []scanInput(RPN_stack, symbol_stack)print calRPN(RPN_stack)if name == 'main':main()calRPN.pysymbol_priority = {}symbol_priority[0] = ['#']symbol_priority[1] = ['(']symbol_priority[2] = ['+', '-']symbol_priority[4] = [')']def comparePriority(symbol, RPN_stack, symbol_stack): '''Compare priority between two symbols'''global symbol_priorityif len(symbol_stack) > 0:symbol_pop = symbol_stack.pop()else:returnfor list in symbol_priority.values():if (symbol in list) and (symbol_pop in list):'''same priority'''symbol_stack.append(symbol_pop)symbol_stack.append(symbol)returnelif symbol in list:'''symbol is smaller'''RPN_stack.append(symbol_pop)#recusion callcomparePriority(symbol, RPN_stack, symbol_stack)returnelif symbol_pop in list:'''symbol is bigger'''symbol_stack.append(symbol_pop)symbol_stack.append(symbol)returnelse:continuesymbol_stack.append(symbol_pop)returndef scanEveryone(input_string, RPN_stack, symbol_stack): for ch in input_string:if ch.isdigit():RPN_stack.append(ch)else:if len(symbol_stack) > 0:if ch == '(':symbol_stack.append(ch)elif ch == ')':while True:symbol_pop = symbol_stack.pop()if symbol_pop == '(':breakelse:RPN_stack.append(symbol_pop)else:comparePriority(ch, RPN_stack, symbol_stack)else:symbol_stack.append(ch)def scanInput(RPN_stack, symbol_stack):input_string = raw_input()input_string += '#'scanEveryone(input_string, RPN_stack, symbol_stack) def calRPN(RPN_stack):value_stack = []RPN_stack.append('#')for value in RPN_stack:if value == '#':return value_stack.pop()breakif value.isdigit():value_stack.append(value)else:right_value = value_stack.pop()left_value = value_stack.pop()cal_string = left_value + value + right_valuevalue_stack.append(str(eval(cal_string)))def main():RPN_stack = []symbol_stack = []scanInput(RPN_stack, symbol_stack)print calRPN(RPN_stack)if name == 'main':main()。

(编译原理)逆波兰式算法的源代码

(编译原理)逆波兰式算法的源代码

一.实验目的1.深入理解算符优先分析法2.掌握FirstVt和LastVt集合的求法有算符优先关系表的求法3.掌握利用算符优先分析法完成中缀表达式到逆波兰式的转化二.实验内容及要求将非后缀式用来表示的算术表达式转换为用逆波兰式来表示的算术表达式,并计算用逆波兰式来表示的算术表达式的值。

程序输入/输出示例:输出的格式如下:(1)逆波兰式的生成及计算程序,编制人(2)输入一以#结束的中缀表达式(包括+—*/()数字#)(3)(4)逆波兰式备注:(1)在生成的逆波兰式中如果两个数相连则用&分隔,如28和68,中间用&分隔;(注意:1。

表达式中允许使用运算符(+-*/)、分割符(括号)、数字,结束符#;2。

如果遇到错误的表达式,应输出错误提示信息(该信息越详细越好);3.对学有余力的同学,测试用的表达式事先放在文本文件中,一行存放一个表达式,同时以分号分割。

同时将预期的输出结果写在另一个文本文件中,以便和输出进行对照;三.实验过程1、逆波兰式定义将运算对象写在前面,而把运算符号写在后面。

用这种表示法表示的表达式也称做后缀式。

逆波兰式的特点在于运算对象顺序不变,运算符号位置反映运算顺序。

采用逆波兰式可以很好的表示简单算术表达式,其优点在于易于计算机处理表达式。

2、产生逆波兰式的前提中缀算术表达式3、逆波兰式生成的实验设计思想及算法(1)首先构造一个运算符栈,此运算符在栈内遵循越往栈顶优先级越高的原则。

(2)读入一个用中缀表示的简单算术表达式,为方便起见,设该简单算术表达式的右端多加上了优先级最低的特殊符号“#”.(3)从左至右扫描该算术表达式,从第一个字符开始判断,如果该字符是数字,则分析到该数字串的结束并将该数字串直接输出。

(4)如果不是数字,该字符则是运算符,此时需比较优先关系。

做法如下:将该字符与运算符栈顶的运算符的优先关系相比较.如果,该字符优先关系高于此运算符栈顶的运算符,则将该运算符入栈.倘若不是的话,则将此运算符栈顶的运算符从栈中弹出,将该字符入栈。

表达式avb cvd逆波兰表达式

表达式avb cvd逆波兰表达式

表达式avb cvd逆波兰表达式
表达式 AVB cvd 的逆波兰表达式可以通过以下步骤得出:
1. 将表达式 AVB cvd 转化成算术表达式,即删除所有括号和指数表达式。

2. 将表达式中的变量和常数换成逆波兰表达式的形式。

3. 对每个算术表达式执行递归,直到所有表达式均为常数或运算符。

4. 将递归得到的逆波兰表达式合并,即可得到表达式的逆波兰表达式。

以下是表达式 AVB cvd 的逆波兰表达式:
```
cvd(ab(ov(x,y),z)) // 递归,x 和 y 为变量,z 为常数
= cvd(ab(o(x,y),z)) // 将变量用括号分组,再递归
= cvd((ab)(o(x,y),z)) // 去除括号和指数表达式
= (cvd(ab(o(x,y),z))) // 将逆波兰表达式括起来
= ab(o(x,y),cvd(ab(o(x,y),z))) // 合并逆波兰表达式
```
注意:逆波兰表达式是一种用于表示程序逻辑的数学表达式,它可以用来描述程序的执行流程,也可以用于优化程序的执行效率。

中间代码逆波兰式

中间代码逆波兰式

中间代码逆波兰表示法(Intermediate Code Reverse Polish Notation,简称逆波兰表示法)是一种计算机科学的中间代码表示法。

在逆波兰表示法中,操作符被放在操作数之后。

例如,算术表达式 "2 + 3" 在逆波兰表示法中为 "2 3 +"。

逆波兰表示法的优点在于,它不需要使用括号来表示操作符的优先级。

例如,在普通表示法中,表达式 "2 + 3 * 4" 需要使用括号来表示 "2 + (3 * 4)",但在逆波兰表示法中,它只需要写成 "2 3 4 * +"。

逆波兰表示法在编译器的中间代码生成阶段中广泛应用。

它便于进行代码优化和解析,因为操作符和操作数的顺序使得计算过程可以更容易地被解析和理解。

此外,逆波兰表示法还可以方便地转换为机器代码,因为它不需要进行括号匹配或优先级判断。

在将中间代码转换为逆波兰表示法时,通常需要使用栈数据结构来保存操作数和操作符。

在遇到操作数时,将其压入栈中;在遇到操作符时,弹出栈中的操作数进行计算,并将结果压回栈中。

最后,将栈中的所有元素按照逆波兰表示法的规则输出即可得到中间代码的逆波兰表示形式。

正则表达式逆波兰表达式

正则表达式逆波兰表达式

正则表达式逆波兰表达式
正则表达式和逆波兰表达式是两种不同的表达式形式,它们的应用场景也不同。

正则表达式主要用于匹配和替换字符串,而逆波兰表达式则用于数学计算。

正则表达式是一种通用的字符串匹配规则。

它可以用来进行字符串的匹配、替换、提取等操作。

正则表达式由各种字符和符号组成,用来描述一个字符序列的规则。

例如,表达式`/[a-z]+/`表示匹配所有小写字母的连续序列。

逆波兰表达式是一种特殊的数学表达式格式,它将运算符放在操作数的后面,而不是中间或前面。

例如,表达式`3 + 4`在逆波兰表达式中表示为`3 4 +`。

逆波兰表达式通常用于计算器和编译器中。

正则表达式和逆波兰表达式在语法和应用方面都有很大的不同,因此它们不能互相替代。

只有在对应的场景中使用它们才能发挥最大的作用。

- 1 -。

1198c++逆波兰表达式

1198c++逆波兰表达式

逆波兰表示法(Reverse Polish Notation,RPN)是一种数学表达式表示法,其中操作符跟在操作数之后。

例如,常规的中缀表达式"2 + 3" 在逆波兰表示法中写作"2 3 +"。

下面是一个简单的C++ 程序,用于将逆波兰表达式转换为普通的中缀表达式:
这个程序首先定义了一个辅助函数 infix,它接受一个逆波兰表达式作为参数,并返回相应的中缀表达式。

该函数使用一个栈来存储操作符,并在遍历逆波兰表达
式时将数字字符添加到结果字符串中。

当遇到操作符时,将其推入栈中。

最后,将栈中的所有操作符弹出并添加到结果字符串中。

这样,我们就得到了对应的中缀表达式。

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

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

波兰表达式(也被称为“正序波兰式”或“前缀波兰式”)是一种用于表示算术表达式的表达式语法。

它的特点是将操作符位于操作数的前面,
而不是像通常的算术表达式那样将操作符位于操作数的后面。

以数学表达式2 + 3 * 4为例,其通常的写法是熟悉的,2 + 3 * 4就是它的原始表达式形式,其计算结果为14。

这种表达式形式被称之为中缀
表达式,因为运算符在中间。

而波兰表达式中,则把算式写成* 3 + 2 4这种形式,也就是在各个操作数之前加上操作符,这一种表达式被称为前缀表达式,其结果也是14。

逆波兰表达式(也称为后缀表达式或逆序波兰表达式)是一种不需要
括号来标识操作符的表达式:从计算机科学的角度来看,它是一种中
间代码,它也被称为前叶编码,它用于将常规表达式转换为用标记标
记的表达式。

以上面的算式2 + 3 * 4为例,用逆波兰表达式表示为2 3 4 * +,也就是在操作数后面加上操作符,其结果为14。

总之,波兰表达式和逆波兰表达式都是一种表示数学表达式的方法。

它们在计算机计算领域中具有广泛的用途,例如,用于编程语言的中
间代码为编译器,以及用于复杂的算术表达式的计算,都是非常有用的。

c语言实现逆波兰表达式!

c语言实现逆波兰表达式!
if(a[i] >= '0' && a[i] <= '9'){ double f = getSum(&i); operNum[top++] = f;
}else if(a[i] == ' '){ i++;
}else if(a[i] == '+'){ x1 = operNum[--top]; x2 = operNum[--top]; operNum[top++] = x1 + x2; i++;
博客园 用户登录 代码改变世界 密码登录 短信登录 忘记登录用户名 忘记密码 记住我 登录 第三方登录/注册 没有账户, 立即注册
c语 言 实 现 逆 波 兰 表 达 式 !
C语言实现逆波兰表达式 (栈的应用 )
#include<iostream> #include<cstdio> using namespace std; const int MAXSIZE = 110; char a[MAXSIZE]; double operNum[MAXSIZE]; ​ double getSum(int* i){//地址传递,可以在边求值时边改变i的原值。如若是值传递,会导致值的重复算
}else if(a[i] == '-'){ x1 = operNum[--top]; x2 = operNum[--top]; operNum[top++] = x2 - x1; i++;
}else if(a[i] == '*'){ x1 = operNum[--top]; x2 = operNum[--top]; operNum[top++] = x1 * x2; i++;

逆波兰(加、减、乘、除、括号)表达式原理及C++代码实现

逆波兰(加、减、乘、除、括号)表达式原理及C++代码实现

逆波兰(加、减、乘、除、括号)表达式原理及C++代码实现当我们输⼊⼀个数学表达式,是中缀表达式,我们⾸先转换为后缀表达式(逆波兰表达式),然后再进⾏求值。

代码思路:(1)⾸先对输⼊的中缀表达式合法性进⾏判断,bool isStringLegal(const char* str); 函数实现。

(2)然后把中缀表达式转换为后缀表达式。

(3)根据后缀表达式求出结果,double getTheResult(vector<string> &vec);函数实现。

注意:表达式的运算符可以输⼊加、减、乘、除、括号,输⼊的数据为整形数据,计算结果为double型数据。

1 #include <iostream>2 #include <math.h>3 #include <map>4 #include <vector>5 #include <string.h>6 #include <memory>7 #include <string>8 #include <stdio.h>9 #include <stack>10 #include <stdlib.h>1112using namespace std;1314#define MAX_STRING_LENGTH 1001516/* 解析当前的整形数据,并把整形数据转换为string型 */17string analyData(const char* str, int &i);1819/* 根据逆波兰表达式求表达式的值 */20double getTheResult(vector<string> &vec);2122/* 判断该字符是否是 + - * / ( ) */23bool isCalChar(const char ch);2425/* 判断输⼊的中缀表达式是否合法 */26bool isStringLegal(const char* str);27282930/* 解析当前的整形数据,并把整形数据转换为string型 */31string analyData(const char* str, int &i)32 {33int temp = i++;34while(str[i] >= '0' && str[i] <= '9' && str[i] != '\0')35 {36 i++;37 }3839string s(str+temp,str+i);4041return s;42 }4344/* 根据逆波兰表达式求表达式的值 */45double getTheResult(vector<string> &vec)46 {47 vector<string>::iterator it;48 stack<double> sta;4950string strTemp;51double d = 0, d1 = 0, d2 = 0;5253for(it = vec.begin(); it != vec.end(); it++)54 {55 strTemp = (*it);5657if(strTemp == "+")58 {59 d1 = sta.top();60 sta.pop();6162 d2 = sta.top();63 sta.pop();6465 d = d1 + d2;66 sta.push(d);67 }68else if(strTemp == "-")69 {70 d1 = sta.top();71 sta.pop();7273 d2 = sta.top();74 sta.pop();7576 d = d2 - d1;77 sta.push(d);78 }79else if(strTemp == "*")80 {81 d1 = sta.top();82 sta.pop();8384 d2 = sta.top();85 sta.pop();8687 d = d2 * d1;88 sta.push(d);89 }90else if(strTemp == "/")91 {92 d1 = sta.top();93 sta.pop();9495 d2 = sta.top();96 sta.pop();9798 d = d2 / d1;99 sta.push(d);100 }101else102 {103const char *p = strTemp.c_str();104 d = atoi(p);105 sta.push(d);106 }107 }108return sta.top();109 }110111/* 判断该字符是否是 + - * / ( ) */112bool isCalChar(const char ch)113 {114if(ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '(' || ch == ')') 115 {116return true;117 }118119return false;120 }121/* 判断输⼊的中缀表达式是否合法 */122bool isStringLegal(const char* str)123 {124/* 判断是否是空串 */125if(NULL == str)126 {127return false;128 }129130int len = strlen(str);131int i = 0;132int flag = 0;133134/* 字符串的开头和末尾是否是数字 */135if(str[0] > '9' || str[0] < '0' || str[len-1] > '9' || str[len-1] < '0')136 {137return false;138 }139140141for(i = 0; str[i] != '\0'; i++)142 {143/* 是否有除了加减乘除括号之外的字符 */144if(isCalChar(str[i]) == false)145 {146return false;147 }148149/* 判断是否有两个连续的符号 */150if(i < len-1 && isCalChar(str[i]) == true)151 {152if(isCalChar(str[i+1]) == true)153 {154return false;155 }156157 }158159/* 判断括号是否成对 */160if(str[i] == '(')161 {162 flag++;163 }164else if(str[i] == ')')165 {166 flag--;167 }168169/* 判断是否出现 )( 这样的情况 */170if(flag < 0)171 {172return false;173 }174 }175176/* 判断括号是否匹配 */177if(flag != 0)178 {179return false;180 }181182return true;183 }184185int main(void)186 {187char str[MAX_STRING_LENGTH] = {0};188int i = 0;189string data;190191/* 存放运算符表达式的栈 */192 stack<char> oper_char;193194/* 存放后缀表达式 */195 vector<string> post_str;196197/* 输⼊中缀的表达式 */198 gets(str);199200/* 判断输⼊的中缀表达式是否合法 */201if(isStringLegal(str) != true)202 {203 cout << "This expression is not legal." << endl; 204 }205else206 {207/* 将中缀表达式转换为后缀表达式 */208for(i = 0; str[i] != '\0'; i++)209 {210/* 如果该字符为数字,解析该数字,并压⼊栈 */ 211if(str[i] >= '0' && str[i] <= '9')212 {213 data = analyData(str,i);214 post_str.push_back(data);215 i--;216 }217else if(str[i] == '(')218 {219 oper_char.push(str[i]);220 }221else if(str[i] == ')')222 {223char chtemp[2] = {0};224225 chtemp[0] = oper_char.top();226227while(chtemp[0] != '(')228 {229string strtemp(chtemp);230 post_str.push_back(strtemp);231 oper_char.pop();232233 chtemp[0] = oper_char.top();234 }235 oper_char.pop();236 }237else if(str[i] == '+' || str[i] == '-')238 {239char chtemp[2] = {0};240241/* 全部出栈,但是碰到 '('就要停⽌出栈 */242while(oper_char.size() != 0)243 {244 chtemp[0] = oper_char.top();245if(chtemp[0] == '(')246 {247break;248 }249250 oper_char.pop();251252string strtemp(chtemp);253 post_str.push_back(strtemp);254 }255256/*将当前的表达式符号⼊栈*/257 oper_char.push(str[i]);258 }259else if(str[i] == '*' || str[i] == '/')260 {261char chtemp[2] = {0};262while(oper_char.size() != 0)263 {264 chtemp[0] = oper_char.top();265if(chtemp[0] == '(' || chtemp[0] == '+' || chtemp[0] == '-') 266 {267break;268 }269else270 {271 oper_char.pop();272273string strtemp(chtemp);274 post_str.push_back(strtemp);275 }276 }277278/*将当前的表达式符号⼊栈*/279 oper_char.push(str[i]);280 }281 }282283/* 存放表达式的栈可能还有数据 */284while(!oper_char.empty())285 {286char chtemp[2] = {0};287 chtemp[0] = oper_char.top();288 oper_char.pop();289290string strtemp(chtemp);291 post_str.push_back(strtemp);292 }293294/* 把逆波兰表达式求值 */295 cout << getTheResult(post_str) << endl;296 }297298return0;299 }。

逆波兰表达式转换

逆波兰表达式转换

理由 操作数 操作数
操作数 操作数 操作数 理由 操作数 操作数
理由 操作数
*(((C-D*E)/F)/G)*H (((C-D*E)/F)/G)*H ((C-D*E)/F)/G)*H
(C-D*E)/F)/G)*H C-D*E)/F)/G)*H -D*E)/F)/G)*H
D*E)/F)/G)*H *E)/F)/G)*H E)/F)/G)*H
+(C*D)+E (C*D)+E C*D)+E
*D)+E D)+E )+E +E E 空 空
输入 (A-B)*(((C-D*E)/F)/G)*H
A-B)*(((C-D*E)/F)/G)*H -B)*(((C-D*E)/F)/G)*H B)*(((C-D*E)/F)/G)*H
)*(((C-D*E)/F)/G)*H
若它是一个闭括号(右括号),则弹出操作符到输出,直到遇到一个开括号。弹出并丢弃该
操作符“/” 若它是一个闭括号(右括号),则弹出操作符到输出,直到遇到一个开括号。弹出并丢弃该 运算符优先级相同,弹出栈顶运算符,并把当前运算符压入堆栈
输入
(A-B)*(C+D)+E A-B)*(C+D)+E -B)*(C+D)+E
B)*(C+D)+E )*(C+D)+E
*(C+D)+E (C+D)+E C+D)+E
+D)+E D)+E
)+E +E E 空 空
输入 (A*B)+(C*D)+E A*B)+(C*D)+E
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
SeqStack<float> OPND;
cout<<post<<endl;
while(post[i]!='#')
{
// OPTR.PrintStack();
// OPND.PrintStack();
// system("pause");
if(post[i]>='0' && post[i]<='9' || post[i]=='.')
else if(s[i]==')')
{
while(OPTR.GetTop()!='(')
d[j++]=OPTR.Pop();
OPTR.Pop();//弹出多余的'('
}
else if (s[i]>='0' && s[i]<='9' || s[i]=='.')
{
while(s[i]>='0' && s[i]<='9' || s[i]=='.')
d[j++]=s[i++];
d[j++]=' ';
i--;
}
else//是运算符
{
char s1=s[i],s2=OPTR.GetTop();
if (pos(s1)>pos(s2))
SeqList <DataType>L;
int top; //栈顶指针,指示栈顶元素在数组中的下标
};
#endif
SeqStacklib.h
#include <iostream>
using namespace std;
#include "SeqStack.h"
template <class T>
class SeqList
{
public:
SeqList( ){length=0;} //无参构造函数,创建一个空表
SeqList(T a[ ], int n); //有参构造函数
void Insert(int i, T x); //在线性表中第i个位置插入值为x的元素
int pos(char c)
{
int i;
for(i=0;i<9;i++)
if(C[i]==c)
return rank[i];
}
void preIntoPost(char *s,char *d)
{// (34.5+4*5)/2+5-->34.5 4 5 * + 2 / 5 +
for (int j=length; j>=i; j--)
data[j]=data[j-1]; //注意第j个元素存在数组下标为j-1处
data[i-1]=x;
length++;
}
template <class T>
T SeqList<T>::Delete(int i)
return 0; //退出循环,说明查找失败
}
template <class T>
void SeqList<T>::PrintList( )
{
for (int i=0; i<length; i++)
cout<<data[i]<<" ";
cout<<endl;
}
template <class T>
T computeV(T a,T b,char c)
{
T temp;
switch(c)
{
case '+':
temp=a+b;
break;
case '-':
temp=a-b;
break;
case '*':
T Get(int i);
private:
T data[MaxSize]; //存放数据元素的数组
int length; //线性表的长度
};
#endif
SeqStack.h
#ifndef SEQSTACK_H
#define SEQSTACK_H
{
if (length==0) throw "下溢";
if (i<1 || i>length) throw "位置非法";
T x=data[i-1];
for (int j=i; j<length; j++)
data[j-1]=data[j]; //注意此处j已经是元素所在的数组下标
SeqStack( ) ; //构造函数,栈的初始化
~SeqStack( ); //析构函数
void Push(DataType x); //将元素x入栈
DataType Pop( ); //将栈顶元素弹出
DataType GetTop( ); //取栈顶元素(并不删除)
int Empty( ); //判断栈是否为空
void PrintStack();
private:
// DataType data[StackSize]; //存放栈元素的数组
gets(s);
preIntoPost(s,d);
cout<<d<<endl;
cout<<PostExpressionFind(d)<<endl;
return 0;
}
seqlist.h
#ifndef SeqList_H
#define SeqList_H
const int MaxSize=10; //10只是示例性的数据,可以根据实际问题具体定义
temp=a*b;
break;
case '/ຫໍສະໝຸດ : temp=a/b; break;
case '%':
temp=(int)a%(int)b;
break;
case '^':
{
T i=0;
temp=1;
while(fabs(i-b)>1e-6)
itpmain.cpp
#include <iostream>
using namespace std;
# include <math.h>
#include "seqstacklib.h"
char C[9]={'+','-','*','/','%','^','(',')','#'};
int rank[9]={1,1,2,2,2,3,0,0,-1}; //根据c求它的优先级
#include "SeqList.h"
template <class T>
SeqList<T>::SeqList(T a[ ], int n)
{
if (n>MaxSize) throw "参数非法";
for (int i=0; i<n; i++)
data[i]=a[i];
//设表达式结束符为#
int i=0,j=0;//s[i]输入的字符,d[j]结果字符
SeqStack<char> OPTR;
OPTR.Push('#');
while(s[i]!='#')
{
if(s[i]=='(')
{
OPTR.Push('(');
}
#include "seqlistlib.h"
//const int StackSize=10; //10只是示例性的数据,可以根据实际问题具体定义
template <class DataType> //定义模板类SeqStack
class SeqStack
{
public:
{
j=0;
while(post[i]>='0' && post[i]<='9' || post[i]=='.')
exp[j++]=post[i++];
exp[j]=0;
OPND.Push(atof(exp));
}
else if(post[i]==' ')
{
temp*=a;
i++;
}
}
}
return temp;
}
double PostExpressionFind(char *post)
{
相关文档
最新文档