数据结构表达式求值代码

合集下载

数据结构实验报告表达式求值

数据结构实验报告表达式求值

数据结构实验报告题目:编制一个表达式求值的程序。

一.需求分析1.本演示程序中,利用堆栈存储结构存储读入的运算符,输入的限定范围是数字(0—9),以及+*/()。

输入字符串限定长度为20,可以根据需要进行改变。

如果遇到不是以上范围或者连续输入两个运算符,如:++,则会提示输入错误,请重新输入。

输出的结果是转换后的后序表达式,以及float型数字,不会含有非法字符。

2.演示程序采用的是文件输入,只需要在源代码中输入要输入的文件的地址,然后就可以在文本文件中进行输入,运行过程中会自动读取,输出文本输入的表达式,及运算结果。

3.程序执行的命令包括:1)构造字符优先级比较表,比较优先关系2)文件输入3)构造堆栈,运算符入栈4)堆栈输出,变为后序表达式,并计算5)输出结果,结束4.测试数据文件地址:C:\\Users\\lenovo\\Desktop\\4.txt1) 输入:(35+20/2)*2-4/2+12正确输出结果是:100.00002)输入:(35+20/2)*2-/2+12结果是:error input3) 输入:a+ar/3=135结果是:error input二.概要设计为实现以上程序功能,需运用堆栈用于存储运算符,因此需要定义抽象数据类型。

1.堆栈的抽象数据类型定义为:ADT stack{数据对象:D={ai|ai∈正整数,i=0,1,2,3,…n,及{+-*/()}}数据关系:R1={<ai-1,a1>|ai-1,ai∈D}基本操作:Init stack(&s)操作结果:构造一个空的堆栈sPush stack(&s, e)初始条件:存在堆栈s操作结果:元素e压入堆栈s,top+1Pop (&s,e)初始条件:栈s已经存在且非空操作结果:删除栈顶元素e,输出其值,top-12.程序包含三个模块:1)运算符优先关系模块2)主程序模块;Int main(void){初始化;Do{接受命令;处理命令;}while(“命令”=”退出”);}3)堆栈模块三.详细设计1.程序源代码解释为:float Result(int c,float r[],int top){ //定义输出结果int j;float temp;switch(c){ //以下是四种基本运算的计算定义,运算完成后直接将top-1值赋予topcase 42:r[top-1]=r[top-1]*r[top];top=top-1;break; //乘法case 43:r[top-1]=r[top-1]+r[top];top=top-1;break;///加法case 45:r[top-1]=r[top-1]-r[top];top=top-1;break;//减法case 47:r[top-1]=r[top-1]/r[top];top=top-1;break;// 除法case 94:for(j=1,temp=r[top-1];j<r[top];j++) //平方或者几次方的运算temp=r[top-1]*temp; //循环相乘r[top-1]=temp;top=top-1;break;}return(r[top]);}if(temp1!=1){while(top>=1){ //栈不空的时候,栈中元素赋给houzhi,并计数biaozhi[b++]=i;houzhi[i]=duizhan[top-1];top=top-1;i=i+1;}max=i; //从0到i循环输出后序表达式for(i=0,b=0;i<max;i++){if(i!=biaozhi[b])printf("%d ",houzhi[i]) ; //输出后序表达式中的数字else {printf("%c ",houzhi[i]); //输出后序表达式中的运算符b=b+1;}}top=-1;for(i=0,b=0;i<max;i++){ //从0到maxif(i!=biaozhi[b]){top=top+1;result[top]=houzhi[i]; //将后值赋予result,调用result函数,进行Result运算}else {Result(houzhi[i],result,top); //运算结束,输出栈顶值,既是运算结果top--;b=b+1;}}printf("\n\nThe result is %f ",Result(houzhi[i],result,top)); //输出并打印结果}}getch();return 0;///返回0}2.程序的模块调用:主程序↓文件打开读入字符↓输入字符有效及优先级的判断↓运算模块↓输出结果四.调试分析1.本次作业的核心就是利用堆栈将中序表达式改成后序表达式,然后进行表达式的求值。

表达式求值(数据结构-栈的应用)

表达式求值(数据结构-栈的应用)

表达式求值(数据结构-栈的应⽤)⼀.问题描述:限制:只含有‘+’,‘-’,‘*’,‘/ ’和圆括号,正整数。

表⽰:字符数组,栈。

中缀表达式:在程序语⾔中,运算符位于两个运算数中间的表达式称为中缀表达式,例如 1+2*3.中缀表达式运算规则:先乘除,后加减,从左到右,先括号内,后括号外,因此中缀表达式不仅要判断运算符的优先级,⽽且还有处理括号。

后缀表达式:运算符在运算数的后⾯,如1+2*3的后缀表达式:1 2 3*,在后缀表达式中已经考虑了运算符的优先级,没有括号,只有运算数和运算符。

后缀表达式的运算:按照运算符的次序进⾏的。

例如123*+,从左到右扫描时,第⼀个运算符为*,先执⾏2*3=6,第⼆个运算符为‘+’,执⾏1+6=7。

⼆ .表达式求值的过程:将算术表达式转换成后缀表达式,然后对后缀表达式求值。

1.将算术表达式转换为后缀表达式。

(1)从左到右⼀次扫描中缀表达式的每⼀个字符,如果是字符串,直接写⼊后缀表达式。

(2)如果遇到的是' ( ',则压⼊操作符栈,遇到‘(’时,将栈中的元素放到后缀表达式中,直达栈顶元素为'('时,将栈顶元素'('删除,不需要⼊栈。

(3)如果遇到的是操作符,则将操作符和操作符栈顶元素⽐较。

:如果a[i]的运算符的优先级⼩于等于栈顶元素的优先级,退栈运算符并放到后缀表达式中,直到a[i]的运算符优先级⼤于栈顶运算符的优先级:否则⼊栈。

(4)重复上述步骤,知道中缀表达式的结束符标记“#”,转换结束。

我的代码:#include<bits/stdc++.h>using namespace std;stack<char>f;//操作符栈stack<double>s;//操作数栈bool flag;int prior(char ch)//运算符的优先级{switch(ch){case'+':case'-':return 1;case'*':case'%':case'/':return 2;default:return 0;//括号}}string trans(string a){while(!f.empty()) f.pop();f.push('#');string ret="";//保存中缀表达式int len=a.size(),i=0;while(i<len){if(a[i]==' '||a[i]=='=')//??{i++;continue;}else if(a[i]=='(')f.push(a[i++]);else if(a[i]==')'){while(f.top()!='('){ret+=f.top();ret+=' ';f.pop();}f.pop();//(出栈i++;}else if(a[i]=='+'||a[i]=='-'||a[i]=='*'||a[i]=='/'||a[i]=='%'){while(prior(f.top())>=prior(a[i]))//如果a[]的运算符的优先级⼩于等于栈顶元素的优先级,退栈运算符并放到后缀表达式中,直到a[i]的运算符优先级⼤于栈顶运算符的优先级ret+=f.top();ret+=' ';f.pop();}f.push(a[i++]);}else{while((a[i]>='0'&&a[i]<='9')||a[i]=='.'){ret+=a[i++];}ret+=' ';}}while(f.top()!='#'){ret+=f.top();ret+=' ';f.pop();}ret+='=';return ret;}double cal(double a,double b,double ch)//计算{if(ch=='+') return a+b;if(ch=='-') return a-b;if(ch=='*') return a*b;if(ch=='%') return ((int)a%(int)b);if(ch=='/'){if(b!=0)return a/b;flag=true;return 0;}}double solve(string a)//后缀表达式计算{string t=trans(a);while(!s.empty()) s.pop();flag=false;int len=t.length(),i=0;while(i<len){if(t[i]==' '||t[i]=='='){i++;continue;}else if(t[i]=='+'||t[i]=='-'||t[i]=='*'||t[i]=='/'||t[i]=='%') {double num1,num2;num1=s.top();s.pop();num2=s.top();s.pop();s.push(cal(num1,num2,t[i]));i++;}else{double x=0;while(t[i]>='0'&&t[i]<='9'){x=x*10+t[i]-'0';i++;}if(t[i]=='.'){double k=10.0,y=0;i++;while(t[i]>='0'&&t[i]<='9'){y+=((t[i]-'0')/k);i++;k*=10;;}x+=y;}s.push(x);}}return s.top();}int main(){int num;scanf("%d",&num);while(num--){cin>>a;// cout<<e.trans(a)<<endl;//将中缀表达式装换为后缀表达式 cout<<solve(a)<<endl;}return 0;}。

数据结构-算术表达式求值(含需求分析和源代码)

数据结构-算术表达式求值(含需求分析和源代码)

需求分析(附代码)一、需求分析(1)首先定义两个栈OPTR、OPND,栈OPTR用于存放运算符,栈OPND 用于存放操作数;定义一个一维数组expr【】存放表达式串。

(2)主函数主要包括两部分:(1)判断运算符优先权,返回优先权高的;(2)操作函数。

(3)开始将‘#’入操作符栈,通过一个函数来判别算术运算符的优先级。

且规定‘#’的优先级最低。

在输入表达式的最后输入‘#’,代表表达式输入结束。

在表达式输入过程中,遇操作数则直接入栈。

遇到运算符则与栈顶运算符比较优先级,当前运算符优先级高(前面的运算还不应执行)则当前运算符入栈,扫描下一符号;否则栈顶运算符出栈,两操作数出栈,进行运算,所得结果入数栈,重新比较当前运算符(注意当前运算符未变)与新栈顶运算符。

如此重复直到栈顶运算符与当前符号均为‘#’,运算结束。

(4)最初实现的加、减、乘、除及带小括号的基本运算,但考虑到实用性,后来的设计中有加上了乘方运算。

在乘方运算中借用了C库中自带的乘方函数pow。

二、概要设计1、设定栈的抽象数据类型定义:ADT Stack {数据对象:D={ ai | ai∈ElemSet, i=1,2,...,n,n≥0 }数据关系:R1={ <ai-1, ai >| ai-1, ai∈D, i=2,...,n }约定an端为栈顶,a1端为栈底。

基本操作:InitStack(&S)操作结果:构造一个空栈S。

DestroyStack(&S)初始条件:栈S已存在。

操作结果:栈S被销毁。

StackEmpty(S)初始条件:栈S已存在。

操作结果:若栈S为空栈,则返回TRUE,否则FALE。

StackLength(S)初始条件:栈S已存在。

操作结果:返回S的元素个数,即栈的长度。

GetTop(S, &e)初始条件:栈S已存在且非空。

操作结果:用e返回S的栈顶元素。

ClearStack(&S)初始条件:栈S已存在。

数据结构表达式求值(可以求小数与多位数)

数据结构表达式求值(可以求小数与多位数)
四、实验步骤 #include "stdafx.h" #include <iostream.h> #include <stdlib.h> #include <math.h> #include <malloc.h> #include <String> #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 #define OPSETSIZE 7 typedef int Status; float Operate(float a, char theta, float b); Status In(char Test,char TestOp[7]); char precede(char Aop, char Bop); char OPSET[OPSETSIZE]={'+' , '-' , '*' , '/' ,'(' , ')' , '#'}; typedef struct{ char *base; char *top; int stacksize; }SqStackOPTR; typedef struct{ float *base; float *top; int stacksize; }SqStackOPND; Status InitStackOPTR(SqStackOPTR &S){ //初始化栈 S.base=(char *)malloc(sizeof(char) * STACK_INIT_SIZE);
//栈顶压入一个数
S.top++; } char PopOPTR(SqStackOPTR &S,char &e){ --S.top; e=*S.top; return e; } float PopOPND(SqStackOPND &S,float &e){ --S.top; e=*S.top; return e; } Status GetTopOPTR(SqStackOPTR &S,char &e){ e=*(S.top-1); return e; } float GetTopOPND(SqStackOPND &S,float &e){ e=*(S.top-1); return e; } unsigned char Prior[7][7] = { '>','>','<','<','<','>','>', '>','>','<','<','<','>','>', '>','>','>','>','<','>','>', '>','>','>','>','<','>','>', // 算符间的优先关系 //取栈顶元素

数据结构表达式求值(栈)

数据结构表达式求值(栈)
switch(ch)
{
case '+':c=a+b;break;
case '-':c=a-b;break;
case '*':c=a*b;break;
case '/':if(b!=0) c=a/b;
else
{
printf("Error!出现分母为0情况。\n");
return 0;
}
break;
case '%':c=(float)((int)a%(int)b);break;
w=*infixexp;
while((GetTop_SeqStackc(S,&c),c)!='#'||w!='=')
{
if(w==' ')
{
infixexp++;
w=*infixexp;
continue;
}//过滤空格字符。
if(w=='.')
{
*postfixexp=w;
postfixexp++;
}
Push_SeqStackf(S,c);
}
ch=*A++;
}
GetTop_SeqStackf(S,&result);
Destroy_SeqStackf(&S);
return (result);
}//后辍表达式求表达式的值,通过一个浮点型栈实现的。
void main()
{
printf("******************************************************************************\n");

表达式求值(数据结构)

表达式求值(数据结构)
ch (3) 当ch != “#” 时, 执行以下工作, 否则
结束算法,此时在OPND栈的栈顶得到 运算结果。
① 若ch是操作数,进OPND栈,从中缀表达式 取下一字符送入ch; ② 若ch是操作符,比较栈外icp(ch)的优先级和 栈内isp(OPTR)的优先级: 若icp(ch) > isp(OPTR),则ch进OPTR栈, 从中缀表达式取下一字符送入ch; 若icp(ch) < isp(OPTR),则从OPND栈退出 a2 和 a1 , 从 OPTR 栈 退 出 θ, 形 成 运 算 指 令 (a1)θ(a2),结果进OPND栈; 若icp(ch) == isp(OPTR) 且ch == “)”,则从 OPTR栈退出栈顶的“(”,对消括号,然后从 中缀表达式取下一字符送入ch;
优先级 操作符
1
单目-、!
2
*、/、%
3
+、-
4 <、<=、>、>=
5
==、!=
6
&&
7
||
一般表达式的操作符有4种类型:
1 算术操作符 如双目操作符(+、-、 *、/ 和%)以及单目操作符(-);
2 关系操作符 包括<、<=、==、!=、 >=、>。这些操作符主要用于比较;
3 逻辑操作符 如与(&&)、或(||)、非 (!);
38
icp (栈外) 0 8 6 4
21
isp叫做栈内(in stack priority)优先数。
icp叫做栈外(in coming priority)优先数。
操作符优先数相等的情况只出现在括号 配对或栈底的“;”号与输入流最后的“;” 号配对时。

数据结构表达式求值

数据结构表达式求值

数据结构表达式求值最佳答案简易版#include<iostream>using namespace std;#define TRUE 1#define FALSE 0#define Stack_Size 20#define Stack_Float 30/*建立字符栈*/typedef struct{char elem[Stack_Size];//存储定义int top;}Stack_char;void InitStack(Stack_char*S)//初始化顺序栈 {S->top=-1;}int Push(Stack_char *S,char x)//进栈{if(S->top==Stack_Size-1) return (FALSE); S->top++;S->elem[S->top]=x;return (TRUE);}int Pop(Stack_char*S,char*x)//出栈{if(S->top==-1) return(FALSE);else{*x=S->elem[S->top];S->top--;return(TRUE);}}int GetTop(Stack_char*S,char*x)// 取栈顶{if(S->top==-1) return(FALSE);else{*x=S->elem[S->top];return(TRUE);}}char GetTop(Stack_char S){char x;GetTop(&S,&x);return x;}//建立数字栈typedef struct//建立{float elem[Stack_Float];int top;}Stack_float;void InitStack(Stack_float*S)//初始化{S->top=-1;}int Push(Stack_float*S,float e) //进栈{if(S->top==Stack_Float-1) return(FALSE); else{S->top++;S->elem[S->top]=e;return(TRUE);}}int Pop(Stack_float*S,float*x)//出栈{if(S->top==-1) return(FALSE);else{*x=S->elem[S->top];S->top--;return(TRUE);}}int GetTop(Stack_float*S,float*x)// 取栈顶{if(S->top==-1) return(FALSE);else{*x=S->elem[S->top];return(TRUE);}}float GetTop(Stack_float S){float x;GetTop(&S,&x);return x;}bool In(char ch)//判断字符{if(ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='('||ch==')'||ch=='#') return (TRUE);else return(FALSE);}float GetNumber(char*ch)//转化数码{return (*ch-48);}float Execute(float a,char op,float b){switch(op){case'+':return(a+b);break;case'-':return(a-b);break;case'*':return(a*b);break;case'/':return(a/b);break;default:cout<<"不能运算";break;}}char Compare(char x,char ch){if(x=='+'||x=='-')if(ch=='+'||ch=='-'||ch==')'||ch=='#') return ('>'); else return ('<');if(x=='*'||x=='/')if(ch=='(') return('<');else return('>');if(x=='(')if(ch==')') return('=');else return('<');if(x==')')if(ch!='(') return('>');if(x=='#')if(ch=='#') return('=');else return('<');}float ExpEvaluation(){float n,v,a,b;char op;Stack_char OPTR;Stack_float OVS;InitStack(&OPTR);InitStack(&OVS);Push(&OPTR,'#');cout<<"请输入一个表达式串(以#结束)"<<endl;char ch;ch=getchar();while(ch!='#'||GetTop(OPTR)!='#'){if(!In(ch)){n=GetNumber(&ch);Push(&OVS,n);ch=getchar();}elseswitch(Compare(GetTop(OPTR),ch)){case'<':Push(&OPTR,ch);ch=getchar();break;case'>':Pop(&OPTR,&op);Pop(&OVS,&b);Pop(&OVS,&a);v=Execute(a,op,b); Push(&OVS,v);break;case'=':Pop(&OPTR,&op);ch=getchar();break;}}v=GetTop(OVS);return(v);}int main(){cout<<ExpEvaluation()<<endl;system("pause");return 0;}完善版#include<iostream>using namespace std;#define TRUE 1#define FALSE 0#define Stack_Size 20#define Stack_Float 30/*建立字符栈*/typedef struct{char elem[Stack_Size];//存储定义int top;}Stack_char;void InitStack(Stack_char*S)//初始化顺序栈{S->top=-1;}int Push(Stack_char *S,char x)//进栈{if(S->top==Stack_Size-1) return (FALSE); S->top++;S->elem[S->top]=x;return (TRUE);}int Pop(Stack_char*S,char*x)//出栈{if(S->top==-1) return(FALSE);else{*x=S->elem[S->top];S->top--;return(TRUE);}}int GetTop(Stack_char*S,char*x)// 取栈顶{if(S->top==-1) return(FALSE);else{*x=S->elem[S->top];return(TRUE);}}char GetTop(Stack_char S){char x;GetTop(&S,&x);return x;}void ClearStack(Stack_char*S)//清空栈{if(S->top!=-1) S->top=-1;}/*建立数字栈*/typedef struct//建立{float elem[Stack_Float];int top;}Stack_float;void InitStack(Stack_float*S)//初始化{S->top=-1;}int Push(Stack_float*S,float e) //进栈{if(S->top==Stack_Float-1) return(FALSE); else{S->top++;S->elem[S->top]=e;return(TRUE);}}int Pop(Stack_float*S,float*x)//出栈{if(S->top==-1) return(FALSE);else{*x=S->elem[S->top];S->top--;return(TRUE);}}int GetTop(Stack_float*S,float*x)// 取栈顶{if(S->top==-1) return(FALSE);else{*x=S->elem[S->top];return(TRUE);}}float GetTop(Stack_float S){float x;GetTop(&S,&x);return x;}void ClearStack(Stack_float*S)//清空栈{if(S->top!=-1) S->top=-1;}/*一些函数*/char a[7]={ '+','-','*','/','(',')', '#'};char p[7][7]= //优先权集合{ {'>','>','<','<','<','>','>'},{'>','>','<','<','<','>','>'},{'>','>','>','>','<','>','>'},{'>','>','>','>','<','>','>'},{'<','<','<','<','<','=','@'},{'>','>','>','>','@','>','>'},{'<','<','<','<','<','@','='} };bool Ins(char ch)//判断数字{if(ch>=48&&ch<=57) return(TRUE);else return(FALSE);}bool Inc(char ch)//判断字符{if(ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='('||ch==')'||ch=='#')return (TRUE);else return(FALSE);}float GetNumber(char*ch)//转化数码{return (*ch-48);}float Execute(float a,char op,float b){switch(op){case'+':return(a+b);break;case'-':return(a-b);break;case'*':return(a*b);break;case'/':return(a/b);break;default:cout<<"不能运算";break;}}char Compare(char x,char ch){//char x;// GetTop(&S,&x);int i,j,k;for(i=0;i<7;i++){if(x==a[i]) j=i;if(ch==a[i]) k=i;}return p[j][k];}Stack_char OPTR;Stack_float OVS;//InitStack(&OPTR);//InitStack(&OVS);void ExpEvaluation(){InitStack(&OPTR);InitStack(&OVS);Push(&OPTR,'#');cout<<"请输入一个表达式串(以#结束)"<<endl;char ch;int w=0,q=0,y=0,z=0,m=0;float n=0,v,a,b;char op;ch=getchar();if(!Ins(ch)){if(ch=='(') z=1;else if(ch=='-') {w=1;ch=getchar();}//记录输入负号 else{cout<<"输入错误,请重新a";fflush(stdin); //清理缓存ClearStack(&OPTR);ExpEvaluation();exit(1);}}//else {}while(ch!='#'||GetTop(OPTR)!='#'){if(Ins(ch)){n=n*10+GetNumber(&ch);q=1;//记录输入数字y=0;//记录输入字符ch=getchar();}//cout<<"n值"<<n<<endl;//system("pause");if(Inc(ch)){if(ch=='(') z=1;if(w==1){// cout<<"z"<<z<<endl;if(q==0){if(z==1){Push(&OPTR,ch);//cout<<"+++"<<GetTop(OPTR)<<endl; z=0;m=2;//记录负的左括号ch=getchar();continue;}else if(ch=='-') {w=0;ch=getchar();} else{cout<<"输入错误,请重新b";fflush(stdin); //清理缓存ClearStack(&OPTR);ExpEvaluation();exit(1); }}else{cout<<"w"<<w<<endl;n=-n;w=0;if(m==2){n=-n;m--;cout<<"m"<<m<<endl;} } }//else {}if(q==1){Push(&OVS,n);cout<<"栈顶"<<GetTop(OVS)<<endl;n=0;q=0;}if(y==1){if(GetTop(OPTR)=='('&&ch=='-'){w=1;ch=getchar();}else if(ch=='(') z=1;//记录左括号else{//cout<<"c"<<ch<<endl;cout<<"输入错误,请重新c";fflush(stdin); //清理缓存ClearStack(&OPTR);ClearStack(&OVS);ExpEvaluation();exit(1);}}if(y==0||z==1){//cout<<"d"<<ch<<endl;//cout<<"o栈顶"<<GetTop(OPTR)<<endl;//cout<<"***"<<Compare(GetTop(OPTR),ch)<<endl; switch(Compare(GetTop(OPTR),ch)){case'<':Push(&OPTR,ch);y=1;z=0;ch=getchar();//cout<<"e"<<GetTop(OPTR)<<endl;break;case'>':Pop(&OPTR,&op);Pop(&OVS,&b);Pop(&OVS,&a);if(op=='/'&&b==0){cout<<"输入错误,请重新d";fflush(stdin); //清理缓存ClearStack(&OPTR);ClearStack(&OVS);ExpEvaluation();exit(1);}v=Execute(a,op,b);if(m==1){v=-v;m=0;}Push(&OVS,v);//cout<<"*栈顶"<<GetTop(OVS)<<endl; break;case'=':Pop(&OPTR,&op);ch=getchar();break;case'@':cout<<"括号不匹配,请重新e"; fflush(stdin); //清理缓存 ClearStack(&OPTR);ClearStack(&OVS);ExpEvaluation();exit(1);}}}if(!Inc(ch)&&!Ins(ch)){cout<<"输入错误,请重新f";fflush(stdin); //清理缓存ClearStack(&OPTR);ClearStack(&OVS);ExpEvaluation();exit(1);}}v=GetTop(OVS);cout<<v<<endl;system("pause");}int main(){ExpEvaluation();return 0;}。

表达式求值(数据结构)(2023版)

表达式求值(数据结构)(2023版)

表达式求值(数据结构) 表达式求值(数据结构)1.引言1.1 目的1.2 背景1.3 范围2.表达式类型2.1 算术表达式2.1.1 运算符2.1.2 运算数2.2 逻辑表达式2.2.1 逻辑运算符2.2.2 逻辑运算数2.3 字符串表达式2.3.1 字符串连接运算符2.3.2 字符串操作函数3.表达式求值算法3.1 递归下降分析法3.2 栈表达式求值法3.2.1 中缀表达式转后缀表达式3.2.2 后缀表达式求值4.数据结构4.1 操作数栈4.2 运算符栈4.3 后缀表达式栈5.算法实现步骤5.1 输入表达式5.2 初始化栈5.3 处理表达式字符串5.4 根据算法选择相应的方法求值5.5 输出结果6.实例演示6.1 算术表达式求值示例6.2 逻辑表达式求值示例6.3 字符串表达式求值示例7.测试与验证7.1 正常表达式测试7.2 异常表达式测试7.3 性能测试8.总结与展望8.1 本文主要工作8.2 结果评估8.3 存在问题8.4 后续工作附件:附件1、算术表达式求值示例代码附件2、逻辑表达式求值示例代码附件3、字符串表达式求值示例代码法律名词及注释:1.递归下降分析法: 一种基于上下文无关文法进行递归分析的方法,用于处理表达式求值等问题。

2.栈表达式求值法: 使用栈数据结构进行表达式求值的方法。

3.中缀表达式: 常见的数学表达式写法,运算符位于运算数之间。

4.后缀表达式: 也称为逆波兰表达式,运算符位于运算数之后。

5.操作数栈: 用于存储表达式中的操作数的栈。

6.运算符栈: 用于存储表达式中的运算符的栈。

7.后缀表达式栈: 用于存储后缀表达式的栈。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

//代码部分:
#include<iostream>
using namespace std;
#define MAXSIZE 100
typedef char ElemType;//定义栈
typedef struct{
char a[MAXSIZE];
int top;//栈顶指针
}SqStack;
char op[8]={'+','-','*','/','(',')','#'};//运算符集
char ch[7][7]={ //运算符优先关系集{'>','>','<','<','<','>','>'},
{'>','>','<','<','<','>','>'},
{'>','>','>','>','<','>','>'},
{'>','>','>','>','<','>','>'},
{'<','<','<','<','<','=',' '},
{'>','>','>','>',' ','>','>'},
{'<','<','<','<','<',' ','='}
};
void InitStack(SqStack &s)
{
for(int i=0;i<MAXSIZE;i++)
s.a[i]=0;
s.top=0;
}
char Push(SqStack &s,ElemType e)
{
if (s.top==MAXSIZE-1) cout<<"Overflow!"<<endl;
else
{ s.top=s.top+1;
s.a[s.top-1]=e;
}
return e;
ElemType Pop(SqStack &s,ElemType &e)
{
if (s.top==0)
{
cout<<"Stack is empty!"<<endl; return(-1);
}
else
{
e=s.a[s.top-1];
s.top=s.top-1;
return e;
}
}
ElemType GetTop(SqStack s,ElemType& e)
{
if (s.top==0) { cout<<"Stack is empty!"<<endl; return(-1); } else
e=s.a[s.top-1];
return e;
}
bool ifnot(char c)//判断是否是运算符
{
for(int i=0;i<8;i++)
{
if (c==op[i])
return 1;}
return 0;
}
int FirstValue(char ch) //判断字符在数组中的位置
{
int k;
switch(ch)
{
case '+':k=0;break;
case '-':k=1;break;
case '*':k=2;break;
case '/':k=3;break;
case '(':k=4;break;
case ')':k=5;break;
case '#':k=6;break;
}
return k;
}
char Precede(char ch1,char ch2)//判断优先关系的函数
{
int i=0,j=0;
i=FirstValue(ch1);//调用函数
j=FirstValue(ch2);//调用函数
return ch[i][j];//返回优先关系的字符
}
char Operate(int ch3,char theta ,int b)
{
int result;
if(theta=='+'){result=(ch3-'0')+(b-'0');}
if(theta=='-'){result=(ch3-'0')-(b-'0');}
if(theta=='*'){result=(ch3-'0')*(b-'0');}
if(theta=='/'){result=(ch3-'0')/(b-'0');}
return (result+'0');
}
int main()
{
char c;//用来接收字符
char x,theta,e,b,a1,m;//定义临时的字符变量
x=m=theta=e=b=a1=NULL;//给临时变量赋值
SqStack OPTR,OPND;//定义运算符栈和操作数栈
InitStack(OPTR) ;Push(OPTR,'#');//初始化,让#是运算符栈底元素InitStack(OPND);//初始化操作数栈
cout<<"请输入表达式,以#结束"<<endl;
c=getchar();
while(c!='#'||GetTop(OPTR,e)!='#')
{
if(!ifnot(c))//判断是否是运算符
{
Push(OPND,c);
c=getchar();
}//不是运算符则进栈
else
switch (Precede(GetTop(OPTR,e),c))
{
case'<':Push(OPTR,c);c=getchar();break;//栈顶元素优先权低
case'=':Pop(OPTR,x);c=getchar();break;//脱括号并接受下一字符
case'>':Pop(OPTR,theta);Pop(OPND,b);Pop(OPND,a1);//退栈并将运算结果入栈
Push(OPND,Operate(a1,theta,b));
break;
}//swith
}//while
m=GetTop(OPND,e);
cout<<"the last result is "<<m-'0'<<endl;//输出最后结果
return 0;
}
//代码结束:
运行结果:。

相关文档
最新文档