表达式求值(数据结构)
表达式求值源代码(数据结构课程设计)
表达式求值源代码(数据结构课程设计)表达式求值源代码(数据结构课程设计) 数据结构课程设计源代码：表达式求值0900340131 张宁2011.6.26 #include #include /*函数功能：将数字字符串转变成相应的数*/ /*函数参数：char类型数组f，指向int类型变量的指针i*/ /*函数返回值：int类型。
返回数字字符串对应的数*/ int readnumber(char f[],int *i) { int x=0; while(f[*i]>= 0 } opst[top]=e[i]; top++; /*当前元素进栈*/ } i++; /*处理下一个元素*/ } while(top) /*栈中还有的全部运算符赋值到数组f中,包括# */ { f[j++]=opst[--top]; } } main() { int i=0,result,flog=0,flog2=0; char a[100],b[100],x,w; /*数组a用来保存中缀表达式，数组b用来表达后缀表达式，*/printf(“~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~\n“); printf(“ 0代表退出系统\n“); printf(“ 1代表输入算术表达式\n“); printf(“ 2代表判断输入的算术表达式的正确性\n“); printf(“ 3代表查看算术表达式的中缀表达式\n“); printf(“ 4代表查看算术表达式的后缀表达式\n“); printf(“ 5代表给出输入的算术表达式的最终结果\n“); printf(“ 规定：第一步必须先输入算术表达式，然后才能进行其他的操作\n“);printf(“~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~\n“); printf(“版权所有，盗版必究张宁2010/6/24 \n\n\n“); do { printf(“请输入您要操作所对应的数字：“); fflush(stdin); scanf(“%c“, if(48(以#号结尾!) “); i=0; do { scanf(“%c“, }while(a[i++]!= # ); flog=1;printf(“\n\n\n“); break; } else { printf(“请输入正确的选项!\n“); } }while(w!= n } else { printf(“请输入算术表达式：(以#号结尾!) “); do { scanf(“%c“, }while(a[i++]!= # ); flog=1; printf(“\n\n\n“); } break; case 2 : if(flog==0) { printf(“您还没有输入过表达式!\n请您按照规定先输入后判断!\n\n\n“); } else { flog2=1; if(judge(a)) { printf(“表达式符合要求!\n您可以继续下面的操作!\n“); } else { printf(“表达式不符合要求!\n请重新输入!\n“); break; } } break; case 3 : if(flog==0) { printf(“您还没有输入过表达式!\n请您按照规定先输入后算术表达式的中缀表达式\n\n\n“); break; } else if(flog2==0) { printf(“您还没有判断表达式的正确性!\n请您按照规定先判断表达式的正确性后查看算术表达式的中缀表达式\n\n\n“); break; } else { printf(“中缀表达式为：“); i=0; do { printf(“%c“,a[i]); }while(a[i++]!= # ); /*i++;*/printf(“\n\n\n“); } break; case 4 : if(flog==0) { printf(“您还没有输入过表达式!\n请您按照规定先输入后算术表达式的中缀表达式\n\n\n“); break; } else if(flog2==0) { printf(“您还没有判断表达式的正确性!\n请您按照规定先判断表达式的正确性后查看算术表达式的中缀表达式\n\n\n“); break; } else { postfix(a,b); printf(“后缀表达式为：\n“); i=0; do { printf(“%c“,b[i]); }while(b[i++]!= # ); /*i++;*/ printf(“\n\n\n“); } break; case 5 : fflush(stdin); if(f log==0) { printf(“您还没有输入过表达式!\n请您按照规定先输入表达式\n\n\n“); break; } else if(flog2==0) { printf(“您还没有判断表达式的正确性!\n请您按照规定先判断表达式的正确性后查看算术表达式的中缀表达式\n\n\n“); break; } else { /*postfix(a,b);*/ result=evalpost(b); printf(“运算结果为：“); for(i=0;a[i]!= # ;i++) { printf(“%c“,a[i]); } printf(“=%d\n\n\n“,result); } break; } } else { printf(“没有此项操作,请重新输入!\n\n\n“); } }while(x!= 0 ); printf(“\n您已退出系统!\n欢迎下次使用\n“); }。
数据结构课程设计-表达式求值【完整版】
ＸＸXＸXX大学《数据结构》课程设计报告班级：学号：姓名：指导老师:目录一算术表达式求值一、需求分析二、程序得主要功能三、程序运行平台四、数据结构五、算法及时间复杂度六、测试用例七、程序源代码二感想体会与总结算术表达式求值一、需求分析一个算术表达式就是由操作数(oｐeranｄ）、运算符(operator）与界限符（deｌimiter)组成得。
假设操作数就是正整数，运算符只含加减乘除等四种运算符,界限符有左右括号与表达式起始、结束符“#”，如：＃(7+15）*（2３—２8/４）#。
引入表达式起始、结束符就是为了方便.编程利用“算符优先法”求算术表达式得值.二、程序得主要功能（1）从键盘读入一个合法得算术表达式，输出正确得结果。
(2）显示输入序列与栈得变化过程。
三、程序运行平台Ｖｉsｕaｌ C＋+6、0版本四、数据结构本程序得数据结构为栈。
（1）运算符栈部分：struct SqStaｃk ／/定义栈{char *base； //栈底指针ｃｈａr *toｐ; ／/栈顶指针inｔstacｋsiｚe； //栈得长度};inｔInitSｔack (SqＳｔack &ｓ) //建立一个空栈S{ｉf （!(s、ｂａse= (char ＊）ｍalloc(5０＊ｓizeof（chａr）)）)exｉt（0）；ｓ、ｔop=s、bａse;s、staｃksiｚｅ=５0；retuｒn OK；}ｃhar GeｔTop（SqStack s,char &e) /／运算符取栈顶元素｛iｆ (s、ｔop==s、ｂase) //栈为空得时候返回EＲROR｛ﻩ prｉntf(＂运算符栈为空！＼n")；ﻩ reｔurn ERＲＯR;｝elsee＝*（s、ｔoｐ-1); //栈不为空得时候用ｅ做返回值，返回S得栈顶元素，并返回OK returnＯＫ;｝ｉnt Push(SqStacｋ＆s，cｈａr ｅ） //运算符入栈｛if （s、tｏp—s、baｓe >= ｓ、ｓtacksｉzｅ）ﻩ{ｐriｎtf（＂运算符栈满!＼n"）;ﻩs、basｅ=（cｈaｒ*）reａlloｃ(s、bａｓe，(s、sｔackｓｉze+5)*ｓizeoｆ(cｈar））；//栈满得时候,追加5个存储空间ｉf(！s、basｅ)exｉt （OVERＦＬOW）；s、top=s、ｂａsｅ+s、ｓｔacｋsize;s、ｓtaｃksiｚｅ+=５;}ﻩ＊(s、ｔop）＋＋=e；／/把e入栈ﻩｒeturn OK;}ｉnｔ Pop(SqStaｃk &ｓ，char ＆ｅ） /／运算符出栈｛ｉｆ (s、toｐ==s、base) ／/栈为空栈得时候，返回ERＲOＲ｛ｐrintf（＂运算符栈为空!\n”）;ﻩ return ERROＲ;}else｛ﻩﻩe=＊-—ｓ、tｏp；/／栈不为空得时候用e做返回值，删除S得栈顶元素，并返回ＯK return OK；}}iｎt StackTｒaｖerse（ＳqStacｋ&ｓ)／/运算符栈得遍历｛ﻩchar ＊t；ﻩt=s、ｂａｓｅ；ﻩif (s、top＝=s、baｓe）｛ﻩ printｆ（”运算符栈为空！\ｎ”)； //栈为空栈得时候返回ＥＲRORｒeturn ERＲOＲ;}ｗhile（t！＝s、tｏp)｛ﻩﻩｐrｉｎｔf（" %c",＊t)； //栈不为空得时候依次取出栈内元素t++;ﻩ}ｒeturｎ EＲRＯR；｝（2）数字栈部分：strｕｃt SqSｔackn//定义数栈｛ｉnt *bａse; //栈底指针ｉnt＊tｏp； //栈顶指针ｉnｔ sｔacksｉze； //栈得长度｝;inｔIｎｉtStackｎ (SqSｔackn &s) //建立一个空栈Ｓ{s、base=（int＊）malｌoc（50*sｉzeof(int）);if(！ｓ、ｂase）eｘiｔ（OVEＲFLＯW）；//存储分配失败s、top=s、base；s、stacksizｅ=5０;reｔuｒn OK；｝ｉｎt GｅtToｐn(ＳqＳtａcｋn s,inｔ＆e) //数栈取栈顶元素{if（s、ｔop=＝s、base）{prinｔｆ(＂运算数栈为空!\ｎ＂);//栈为空得时候返回ERRORﻩ rｅturｎ ERROR;}eｌseﻩe＝＊（s、toｐ-1);／/栈不为空得时候，用e作返回值，返回S得栈顶元素，并返回OＫreturｎＯK；｝int Pｕshn（SｑStａckn ＆s，int ｅ) //数栈入栈｛if（s、tｏp—s、ｂasｅ＞＝s、stacksiｚe)｛ﻩﻩprｉｎｔf（"运算数栈满!\ｎ"）；／/栈满得时候,追加5个存储空间ﻩs、base=(int＊）realloc (s、baｓe,(s、stａcksize＋5)＊sｉzｅof（ｉnt));ｉf（!s、base) ｅxit (ＯＶERFLOW)；ﻩs、top=ｓ、bａsｅ＋ｓ、stacｋsize;//插入元素e为新得栈顶元素s、stacksｉｚe+=5；}*（s、top）++=e; /／栈顶指针变化returｎOK;}ｉｎt Popｎ(ＳｑSｔacｋn ＆s，iｎt &e)//数栈出栈｛ﻩif （s、top=＝ｓ、base）｛ﻩ pｒiｎtｆ（"运算符栈为空！\n＂);//栈为空栈得视时候，返回ERRＯＲﻩ retｕrn ERROR；ﻩ｝ｅlse｛ﻩﻩe=＊—-ｓ、tｏp；／/栈不空得时候，则删除S得栈顶元素,用e返回其值，并返回OK ﻩreturｎOK；｝}ｉnt StacｋＴraveｒsｅn（SqStackn &s)/／数栈遍历{ﻩiｎｔ＊t;ﻩｔ=s、basｅ ;ﻩif（s、top==s、basｅ）ﻩ｛pｒinｔf(＂运算数栈为空！\n”）；//栈为空栈得时候返回ERRORﻩ rｅｔｕrn ERＲＯＲ；ﻩ｝ﻩwｈile（t！=ｓ、ｔop)ﻩ{priｎtf(” ％d”，*ｔ); /／栈不为空得时候依次输出t＋＋;｝return ERRＯR；｝五、算法及时间复杂度１、算法:建立两个不同类型得空栈,先把一个‘＃’压入运算符栈。
黑龙江大学数据结构考试题
《数据结构课程设计》讲义一、表达式求值问题1.1 问题定义及设计要求表达式求值是程序设计语言编译中的一个最基本问题。
人们在书写表达式时通常采用将运算符放在两个操作数中间的“中缀”表示形式，称为中缀表达式。
但是这种表达式形式对计算机处理来说是不太适合的。
在计算机领域，经常将算术表达式表示成“后缀”表示形式，称为后缀表达式。
如: 中缀表达式3+2*(7-5)对应的后缀表达式为3275-*+。
要求实现（1）算数四则运算中缀表达式到后缀表达式的转换；（2）后缀表达式的求值；（3）中缀表达式的求值。
要求以字符序列的形式从终端输入语法正确的、不含变量的整数表达式。
要求演示在求值过程中运算符栈、操作数栈、输入字符和主要操作过程及运算结果。
要求配备菜单，含如下选项：------------------------------------------------------1. 中缀表达式到后缀表达式的转换2. 后缀表达式的计算3. 中缀表达式的计算4. 退出-------------------------------------------------------1.2 中缀表达式到后缀表达式的转换（1）问题分析假设在算术表达式中只含四种基本运算符，操作数是10以内的整数。
假设一个中缀表达式中没有括号（如4+2*3，它的后缀表达式为423*+）。
在扫描到中缀表达式中的2后，能立即输出+，因为*具有较高优先级，必须必须先运算，因此需先保存+。
也就是说，新扫描运算符优先级必须与前一个运算符的优先级做比较，如果新的运算符优先级高，就要像前一个运算符那样保存它，直到扫描到第二个操作数，将它输出后才能将该运算符输出。
因此，在转化中必须保存两个运算符，后保存的运算符先输出。
用计算机来实现这个转化过程，就需要用到能后进先出的数据结构----栈。
如果在中缀表达式中含小括号，那么由于括号隔离了优先级规则，它在整个表达式的内部产生了完全独立的子表达式。
数据结构课程设计四则运算表达式求值（C语言版）
数据结构课程设计四则运算表达式求值（C语⾔版） 明⼈不说暗话，直接上，输⼊提取码z3fy即可下载。
⽂件中包含程序，程序运⾏⽂件，设计报告和测试样例，应有尽有，欢迎⼩伙伴们在中下载使⽤。
本课程设计为四则运算表达式求值，⽤于带⼩括号的⼀定范围内正负数的四则运算标准（中缀）表达式的求值。
注意事项：1、请保证输⼊的四则表达式的合法性。
输⼊的中缀表达式中只能含有英⽂符号“+”、“-”、“*”、“/”、“(”、“)”、“=”、数字“0”到“9”以及⼩数点“.”，输⼊“=”表⽰输⼊结束。
例如9+(3-1)*3.567+10/2=，特别是请勿输⼊多余空格和中⽂左右括号。
2、输⼊的中缀表达式默认限定长度是1001，可根据具体情况调整字符串数组的长度。
3、请保证输⼊的操作数在double数据类型范围内，单个数字有效数字长度不可超过15位。
本课程设计中操作数是C语⾔中的双精度浮点数类型。
4、本课程设计中的运算数可以是负数，另外如果是正数可直接省略“+”号（也可带“+”号）。
下⾯的程序正常运⾏需要在上⾯的百度⽹盘中下载相应⽂件，否则⽆法正常使⽤哦。
1/*本程序为四则运算表达式求值系统，⽤于计算带⼩括号的四则运算表达式求值。
2具体算法：3先将字符串处理成操作单元（操作数或操作符），再利⽤栈根据四则运算4的运算法则进⾏计算，最后得出结果。
*/56 #include<stdio.h>7 #include<ctype.h>8 #include<stdlib.h>9 #include<string.h>10 #include<stdlib.h>11 #include<ctype.h>1213const int Expmax_length = 1001;//表达式最⼤长度，可根据适当情况调整14struct Ope_unit15 {//定义操作单元16int flag;//=1表⽰是操作数 =0表⽰是操作符 -1表⽰符号单元17char oper;//操作符18double real;//操作数，为双精度浮点数19 };2021void Display();//菜单22void Instru(); //使⽤说明23int Check(char Exp_arry[]);24void Evalua(); //先调⽤Conver操作单元化，再调⽤Calculate函数计算结果并输出25int Conver(struct Ope_unit Opeunit_arry[],char Exp_arry[]);//将字符串处理成操作单元26int Isoper(char ch);//判断合法字符（+ - * / ( ) =）27int Ope_Compar(char ope1,char ope2);//操作符运算优先级⽐较28double Calculate(struct Ope_unit Opeunit_arry[],int Opeunit_count,int &flag);//⽤栈计算表达式结果29double Four_arithm(double x,double y,char oper);//四则运算3031int main()32 {33int select;34while(1)35 {36 Display();37 printf("请输⼊欲执⾏功能对应的数字：");38 scanf("%d",&select);39 printf("\n");40switch(select)41 {42case1: Evalua(); break;43case2: Instru(); break;44case0: return0;45default : printf("⽆该数字对应的功能，请重新输⼊\n");46 system("pause");47 }48 }49return0;50 }5152int Check(char Exp_arry[])53 {//检查是否有⾮法字符，返回1表⽰不合法，0表⽰合法54int Explength=strlen(Exp_arry),i;55for(i=0;i<Explength;i++)56 {57if(!Isoper(Exp_arry[i]) && Exp_arry[i] != '.' && !isdigit(Exp_arry[i]))58return1;59if(isdigit(Exp_arry[i]))60 {61int Dig_number=0,Cur_positoin=i+1;62while(isdigit(Exp_arry[Cur_positoin]) || Exp_arry[Cur_positoin]=='.')63 {64 Dig_number++;65 Cur_positoin++;66 }67if(Dig_number >= 16)//最多能够计算15位有效数字68return1;69 }70 }71return0;72 }7374void Evalua()75 {//先调⽤Conver函数将字符串操作单元化，再调⽤Calculate函数计算结果并输出76char Exp_arry[Expmax_length];77int flag=0;//假设刚开始不合法，1表达式合法，0不合法78struct Ope_unit Opeunit_arry[Expmax_length];7980 getchar();//吃掉⼀个换⾏符81 printf("请输⼊四则运算表达式，以=结尾：\n");82 gets(Exp_arry);83 flag=Check(Exp_arry);84if(flag)85 printf("该表达式不合法！\n");86else87 {88int Opeunit_count = Conver(Opeunit_arry,Exp_arry);89double ans = Calculate(Opeunit_arry,Opeunit_count,flag);90if(flag)91 {92 printf("计算结果为：\n");93 printf("%s%lf\n",Exp_arry,ans);94 }95else96 printf("该表达式不合法！\n");97 }98 system("pause");99 }100101int Conver(struct Ope_unit Opeunit_arry[],char Exp_arry[])102 {//将字符串操作单元化103int Explength=strlen(Exp_arry);104int i,Opeunit_count=0;105for(i=0;i<Explength;i++)106 {107if(Isoper(Exp_arry[i]))//是操作符108 {109 Opeunit_arry[Opeunit_count].flag=0;110 Opeunit_arry[Opeunit_count++].oper=Exp_arry[i];111 }112else//是操作数113 {114 Opeunit_arry[Opeunit_count].flag=1;115char temp[Expmax_length];116int k=0;117for(; isdigit(Exp_arry[i]) || Exp_arry[i]=='.' ;i++)118 {119 temp[k++]=Exp_arry[i];120 }121 i--;122 temp[k]='\0';123 Opeunit_arry[Opeunit_count].real=atof(temp);//将字符转化为浮点数124125//负数126if(Opeunit_count == 1 && Opeunit_arry[Opeunit_count-1].flag==0127 && Opeunit_arry[Opeunit_count-1].oper=='-')128 {129 Opeunit_arry[Opeunit_count-1].flag = -1;130 Opeunit_arry[Opeunit_count].real *= -1;131 }// -9132if(Opeunit_count >= 2 && Opeunit_arry[Opeunit_count-1].flag==0133 && Opeunit_arry[Opeunit_count-1].oper=='-' && Opeunit_arry[Opeunit_count-2].flag==0 134 && Opeunit_arry[Opeunit_count-2].oper !=')')135 {136 Opeunit_arry[Opeunit_count-1].flag = -1;137 Opeunit_arry[Opeunit_count].real *= -1;138 }// )-9139140//正数141if(Opeunit_count == 1 && Opeunit_arry[Opeunit_count-1].flag==0142 && Opeunit_arry[Opeunit_count-1].oper=='+')143 {144 Opeunit_arry[Opeunit_count-1].flag = -1;145 }// +9146if(Opeunit_count >= 2 && Opeunit_arry[Opeunit_count-1].flag==0147 && Opeunit_arry[Opeunit_count-1].oper=='+' && Opeunit_arry[Opeunit_count-2].flag==0148 && Opeunit_arry[Opeunit_count-2].oper !=')')149 {150 Opeunit_arry[Opeunit_count-1].flag = -1;151 }// )+9152 Opeunit_count++;153 }154 }155/*for(i=0;i<Opeunit_count;i++)156 {//查看各操作单元是否正确,1是操作数，0是操作符157 if(Opeunit_arry[i].flag == 1)158 printf("该单元是操作数为：%lf\n",Opeunit_arry[i].real);159 else if(Opeunit_arry[i].flag == 0)160 printf("该单元是操作符为：%c\n",Opeunit_arry[i].oper);161 else162 printf("该单元是负号符为：%c\n",Opeunit_arry[i].oper);163 }*/164return Opeunit_count;165 }166167double Calculate(struct Ope_unit Opeunit_arry[],int Opeunit_count,int &flag)168 {//根据运算规则，利⽤栈进⾏计算169int i,dS_pointer=0,oS_pointer=0;//dS_pointer为操作数栈顶指⽰器，oS_pointer为操作符栈顶指⽰器170double Dig_stack[Expmax_length];//操作数栈（顺序存储结构）171char Ope_stack[Expmax_length];//操作符栈172173for(i=0;i<Opeunit_count-1;i++)174 {175if( Opeunit_arry[i].flag != -1 )176 {177if(Opeunit_arry[i].flag)//是操作数178 {179 Dig_stack[dS_pointer++]=Opeunit_arry[i].real;//⼊操作数栈180//printf("%lf\n",Digit[dS_pointer-1]);181 }182else//是操作符 + - * / ( )183 {184//操作符栈为空或者左括号⼊栈185if(oS_pointer==0 || Opeunit_arry[i].oper=='(')186 {187 Ope_stack[oS_pointer++]=Opeunit_arry[i].oper;188//printf("%oS_pointer\Ope_u_count",Operator[oS_pointer-1]);189 }190else191 {192if(Opeunit_arry[i].oper==')')//是右括号将运算符⼀直出栈，直到遇见左括号193 {194 oS_pointer--;//指向栈顶195 dS_pointer--;//指向栈顶196while(Ope_stack[oS_pointer] != '(' && oS_pointer != 0)197 {198 Dig_stack[dS_pointer-1] = Four_arithm(Dig_stack[dS_pointer-1],Dig_stack[dS_pointer], 199 Ope_stack[oS_pointer--]);//oS_pointer--为操作符出栈200201 dS_pointer--;//前⼀个操作数出栈202//printf("操作数栈顶元素等于%lf\n",Digit[dS_pointer]);203 }204 oS_pointer--;//左括号出栈205206 oS_pointer++;//恢复指向栈顶之上207 dS_pointer++;208 }209else if(Ope_Compar(Opeunit_arry[i].oper,Ope_stack[oS_pointer-1]))//和栈顶元素⽐较210 {211 Ope_stack[oS_pointer++]=Opeunit_arry[i].oper;212//printf("%oS_pointer\Ope_u_count",Operator[oS_pointer-1]);213 }214else//运算符出栈，再将该操作符⼊栈215 {216 oS_pointer--;//指向栈顶217 dS_pointer--;//指向栈顶218while(Ope_Compar(Opeunit_arry[i].oper,Ope_stack[oS_pointer])==0 && oS_pointer != -1) 219 {//当前操作符⽐栈顶操作符优先级⾼220 Dig_stack[dS_pointer-1]=Four_arithm(Dig_stack[dS_pointer-1],Dig_stack[dS_pointer], 221 Ope_stack[oS_pointer--]);222 dS_pointer--;223//printf("操作数栈顶元素等于%lf\n",Digit[dS_pointer]);224 }225 oS_pointer++;//恢复指向栈顶之上226 dS_pointer++;227 Ope_stack[oS_pointer++]=Opeunit_arry[i].oper;228 }229 }230 }231 }232 }233/*for(i=0;i<oS_pointer;i++)234 printf("操作符栈%oS_pointer\Ope_u_count",Operator[i]);235 for(i=0;i<dS_pointer;i++)236 printf("操作数栈%lf\n",Digit[i]);*/237 oS_pointer--;//指向栈顶元素238 dS_pointer--;//指向栈顶元素239while(oS_pointer != -1)240 {241 Dig_stack[dS_pointer-1]=Four_arithm(Dig_stack[dS_pointer-1],Dig_stack[dS_pointer], 242 Ope_stack[oS_pointer--]);//oS_pointer--为操作符出栈243 dS_pointer--;//前⼀个操作数出栈244//printf("操作数栈顶元素为%lf\Ope_u_count",Digit[dS_pointer]);245 }246//printf("%dS_pointer,%dS_pointer\n",oS_pointer,dS_pointer);247if(oS_pointer==-1 && dS_pointer==0)248 flag=1;//为1表⽰表达式合法249return Dig_stack[0];250 }251252int Ope_Compar(char ope1,char ope2)253 {//操作符运算优先级⽐较254char list[]={"(+-*/"};255int map[5][5]={//先⾏后列，⾏⽐列的运算级优先级低为0，⾼为1256// ( + - * /257/* ( */1,0,0,0,0,258/* + */1,0,0,0,0,259/* - */1,0,0,0,0,260/* * */1,1,1,0,0,261/* / */1,1,1,0,0 };262int i,j;263for(i=0;i<5;i++)264if(ope1==list[i]) break;265for(j=0;j<5;j++)266if(ope2==list[j]) break;267return map[i][j];268 }269270double Four_arithm(double x,double y,char oper)271 {//四则运算272switch(oper)//保证不含其它运算符273 {274case'+': return x+y;275case'-': return x-y;276case'*': return x*y;277case'/': return x/y;//y不能为0278default : return0;279 }280 }281282int Isoper(char ch)283 {//判断合法字符 + - * / ( ) =284if(ch=='+' || ch=='-' || ch=='*' || ch=='/' || ch=='(' || ch==')' || ch=='=')285return1;286return0;287 }288289void Display()290 {//打印菜单291 system("cls");292 printf("/******************************************************************************/\n");293 printf("\t\t 欢迎使⽤本四则运算表达式求值系统\n");294 printf("\n\t说明：建议请您先阅读使⽤说明，再输⼊相应的数字进⾏操作，谢谢配合！\n"); 295 printf("\n\t\t1 四则运算表达式求值\n");296 printf("\n\t\t2 使⽤说明\n");297 printf("\n\t\t0 退出\n");298 printf("/******************************************************************************/\n");299 }300301void Instru()302 {//打印使⽤说明303 FILE *fp;304char ch;305if( ( fp=fopen("使⽤说明.txt","r") ) == NULL)306 {307 printf("⽂件打开失败！\n");308 exit(0);309 }310for(; (ch = fgetc(fp)) != EOF; )311 putchar(ch);312 fclose(fp);313 printf("\n");314 system("pause");315 }。
表达式求值(数据结构)
结束算法，此时在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)优先数。
操作符优先数相等的情况只出现在括号 配对或栈底的“;”号与输入流最后的“;” 号配对时。
表达式求值(数据结构)(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.后缀表达式栈: 用于存储后缀表达式的栈。
数据结构表达式求值
数据结构表达式求值在计算机科学中，数据结构是组织和存储数据的方式，而表达式求值则是一个常见且重要的任务。
表达式求值可以帮助我们计算数学表达式的结果，无论是简单的四则运算，还是复杂的包含函数和变量的表达式。
让我们从一个简单的算术表达式开始，比如“2 ＋3 4”。
要计算这个表达式的值，我们不能简单地从左到右依次计算，因为乘法的优先级高于加法。
所以，正确的计算顺序应该是先计算 3 4 ＝ 12，然后再计算 2 ＋ 12 ＝ 14。
为了能够正确地处理表达式中不同运算符的优先级，我们需要使用特定的数据结构和算法。
其中，栈（Stack）是一种非常有用的数据结构。
栈就像是一个只能从一端进出的容器，遵循“后进先出”（Last In First Out，LIFO）的原则。
在表达式求值中，我们可以使用两个栈，一个用来存储操作数（Operand Stack），另一个用来存储运算符（Operator Stack）。
当我们读取表达式中的数字时，将其压入操作数栈；当读取到运算符时，需要和运算符栈顶的运算符比较优先级。
如果当前运算符的优先级高于栈顶运算符，那么将其压入运算符栈；如果当前运算符的优先级低于或等于栈顶运算符，就从操作数栈中弹出相应数量的操作数，进行计算，将结果压回操作数栈，然后再将当前运算符压入运算符栈。
例如，对于表达式“2 ＋3 4”，我们首先读取到数字 2，将其压入操作数栈。
接着读取到“＋”号，此时运算符栈为空，所以将“＋”号压入运算符栈。
然后读取到数字 3，压入操作数栈。
再读取到“”号，由于“”号的优先级高于“＋”号，将“”号压入运算符栈。
接着读取到数字 4，压入操作数栈。
此时，表达式已经读取完毕。
因为“”号的优先级高于“＋”号，所以先从操作数栈中弹出 3 和 4 进行乘法运算，得到 12，将 12 压回操作数栈。
然后从运算符栈中弹出“＋”号，从操作数栈中弹出 2 和 12 进行加法运算，得到 14，这就是表达式的最终结果。
表达式求值
表达式求值数据结构课程设计报告表达式求值专业计算机科学与技术学生姓名班级学号指导教师完成日期表达式求值目录1 概述 (1)课程设计目的 (1)课程设计内容 (1)2 系统需求分析 (1)系统目标 (1)主体功能 (1)开发环境 (1)3 系统概要设计 (2)系统的功能模块划分 (2)系统流程图 (2)4系统详细设计 (3)5 测试 (3)测试方案 (5)测试结果 (5)6 小结 (7)参考文献 (9)附录1 源程序清单 (10)数据结构课程设计报告(2014)表达式求值1 概述课程设计目的1.要求学生达到熟练掌握C语言的基本知识和技能。
2.了解并掌握数据结构的设计方法,具备初步的独立分析和设计能力。
3.提高程序设计和调试能力。
学生通过上机实习,验证自己设计的算法的正确性。
学会有效利用基本调试方法,迅速找出程序代码中的错误并且修改。
4.培养算法分析能力。
分析所设计算法的时间复杂度和空间复杂度,进一步提高程序设计水平。
5.初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能。
课程设计内容设计一个表达式求值的程序。
该程序必须可以接受包含(,),+,-,*,/,%,和^(求幂运算符,a^b=a b)的中缀表达式,并求出结果。
如果表达式正确,则输出表达式的结果;如果表达式非法,则输出错误信息。
2 系统需求分析系统目标利用栈设计一个程序,该程序能够用于表达式求值,程序将读入的中缀表达式转换为后缀表达式,然后读取后缀表达式,输出结果。
输入要求:程序从“”文件中读取信息,在这个文件中如果有多个中缀表达式,则每个表达式独占一行,程序的读取操作在文件的结尾处停止。
输出要求:对于每一个表达式,将其结果放在“”文件的每一行中。
这些结果可能是值(精确到小数点后两位),也可能是错误信息“ERROR IN INFIX NOTATION”。
主体功能能够处理以字符序列的形式输入的不含变量的实数表达式,正确处理负数与小数,判断表达式是否语法正确(包含分母不能为零的情况),正确实现对算术四则混合运算表达式的求值,能够将计算中遇到的问题和结果以文件的形式予以存储。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
中缀算术表达式求值
使用两个栈，操作符栈OPTR (operator)， 使用两个栈，操作符栈OPTR (operator)， 操作数栈OPND(operand)， 操作数栈OPND(operand)， 对中缀表达式求值的一般规则： 对中缀表达式求值的一般规则： (1) 建立并初始化OPTR栈和OPND栈， 建立并初始化OPTR栈和 栈和OPND栈 然后在OPTR栈中压入一个 栈中压入一个“ 然后在OPTR栈中压入一个“#” (2) 从头扫描中缀表达式，取一字符送入 从头扫描中缀表达式， ch (3) 当ch != “#” 时, 执行以下工作, 否则 执行以下工作, 结束算法， 此时在OPND 栈 结束算法 ， 此时在 OPND栈 的栈顶得 到运算结果。 到运算结果。
表达式求值
一个表达式由操作数 亦称运算对象) 一个表达式由操作数(亦称运算对象)、操 操作数( 亦称运算符) 分界符(亦称界限符) 作符 (亦称运算符) 和分界符(亦称界限符) 组成。 组成。 算术表达式有三种表示： 算术表达式有三种表示： 中缀(infix)表示 中缀 表示
<操作数> <操作符> <操作数>，如 A+B； 操作数> 操作符> 操作数> ；
① 若ch是操作数，进OPND栈，从中缀表达式 ch是操作数， OPND栈 取下一字符送入ch； 取下一字符送入ch； ch是操作符，比较栈外icp(ch)的优先级和 ② 若ch是操作符，比较栈外icp(ch)的优先级和 栈内isp(OPTR)的优先级 的优先级： 栈内isp(OPTR)的优先级： isp(OPTR)， ch进OPTR栈 若icp(ch) > isp(OPTR)，则ch进OPTR栈， 从中缀表达式取下一字符送入ch； 从中缀表达式取下一字符送入ch； isp(OPTR)，则从OPND栈 若icp(ch) < isp(OPTR)，则从OPND栈退出 a2 和 a1 ， 从 OPTR 栈 退 出 θ, 形 成 运 算 指 令 (a1)θ(a2)，结果进OPND栈； (a1)θ(a2 结果进OPND栈 “)”， 若icp(ch) == isp(OPTR) 且ch == “)”，则从 OPTR栈 退出栈顶的“ (” ， 对消括号， OPTR 栈 退出栈顶的 “ (”， 对消括号 ， 然后从 中缀表达式取下一字符送入ch； 中缀表达式取下一字符送入ch；
优先级 操作符 1 单目单目-、！ 2 *、/、% 3 +、4 <、<=、>、>= <=、 5 ==、 ==、!= 6 && 7 ||
一般表达式的操作符有4种类型: 一般表达式的操作符有4种类型: 1 算术操作符 如双目操作符（+、-、 如双目操作符（ *、/ 和%）以及单目操作符（-）; 以及单目操作符（ 2 关系操作符 包括<、<=、==、!=、 包括< <=、==、!=、 >=、 >=、>。这些操作符主要用于比较; 这些操作符主要用于比较; 3 逻辑操作符 如与(&&)、或(||)、非 如与(&&)、 (||)、 (!); 4 括号‘(’和‘)’ 它们的作用是改变 括号‘(’和 运算顺序; 运算顺序;
应用后缀表示计算表达式的值
从左向右顺序地扫描表达式， 从左向右顺序地扫描表达式 ， 并用一个 暂存扫描到的操作数 计算结果; 操作数或 栈暂存扫描到的操作数或计算结果; 在后缀表达式的计算顺序中已隐含了加 在后缀表达式的计算顺序中已 隐含了加 括号的优先次序， 括号的优先次序 ， 括号在后缀表达式中 不出现; 不出现; 计算例 a b c d - * + e f ^ g / rst1 rst2 rst3 rst6 rst4 rst5
栈内容 空 A AB ABC ABCD ABr1 Ar2 r3
步 输入 类 型 动 作 9 E 操作数 进栈 10 F 操作数 进栈 11 ^ 操作符 F、 E 退栈 计算 、 退栈, E^F, 结果 r4 进栈 12 G 操作数 进栈 13 / 操作符 G、 r4 退栈 计算 、 退栈, r4/E, 结果 r5 进栈 14 + 操作符 r5、 r3 退栈 计算 、 退栈, r3+r5, 结果 r6 进栈
中缀表达式转换为后缀表达式的算法
操作符栈初始化，将结束符‘ 进栈。 操作符栈初始化，将结束符‘;’进栈。然 后读入中缀表达式字符流的首字符ch； 后读入中缀表达式字符流的首字符ch； 重复执行以下步骤，直到ch 重复执行以下步骤，直到ch = ‘;’，同时 栈顶的操作符也是‘ 停止循环； 栈顶的操作符也是‘;’，停止循环； ch是 操作数直接输出 直接输出， 若 ch 是 操作数 直接输出 ， 读入下一个 字符ch。 字符ch。 ch是操作符，判断ch 的优先级 和 的优先级icp 若 ch是 操作符 ， 判断 ch的优先级 icp和 位于栈顶的操作符op的优先级 ： 的优先级isp 位于栈顶的操作符op的优先级isp：
若 icp (ch) > isp (op)，令ch进栈，读入 (op)， ch进栈 进栈， 下一个字符ch； 下一个字符ch； (op)，退栈并输出； 若 icp (ch) < isp (op)，退栈并输出； (op)，退栈但不输出， 若 icp (ch) == isp (op)，退栈但不输出， 若退出的是“ (”号读入下一个字符 ； 号读入下一个字符ch 若退出的是 “ (” 号读入下一个字符 ch； 算法结束， 算法结束，输出序列即为所需的后缀表 达式。 达式。
栈内容 r3E r3EF r3r4 r3r4G r3r5 r6
利表示转换成它 的前缀表示和后缀表示。 的前缀表示和后缀表示。 为了实现这种转换， 为了实现这种转换 ， 需要考虑各操作符 的优先级。 的优先级。
各个算术操作符的优先级
操作符 ch ; 栈内) isp (栈内 0 栈内 栈外) icp (栈外 0 栈外 ( 1 8 ^ *, /, % +, 7 5 3 6 4 2 ) 8 1
通过后缀表示计算表达式值的过程
顺序扫描表达式的每一项， 顺序扫描表达式的每一项，根据它的类 型做如下相应操作： 型做如下相应操作： 若该项是操作数 则将其压栈 操作数， 压栈； 若该项是操作数，则将其压栈； 若该项是操作符 操作符<op>，则连续从栈中 若该项是操作符 ， 退出两个操作数Y和 ， 退出两个操作数 和X，形成运算指令 X<op>Y，并将计算结果重新压栈。 压栈。 ，并将计算结果重新压栈 当表达式的所有项都扫描并处理完后， 当表达式的所有项都扫描并处理完后， 栈顶存放的就是最后的计算结果。 栈顶存放的就是最后的计算结果。
步 输入 类 型 动 作 1 置空栈 2 A 操作数 进栈 3 B 操作数 进栈 4 C 操作数 进栈 5 D 操作数 进栈 6 - 操作符 D、 C 退栈 计算 、 退栈, C- D, 结果 r1 进栈 7 * 操作符 r1、 B 退栈, 计算 、 退栈 B*r1, 结果 r2 进栈 8 + 操作符 r2、 A 退栈 计算 、 退栈, A*r2, 结果 r3 进栈
isp叫做栈内(in stack priority)优先数。 isp叫做栈内 叫做栈内(in priority)优先数 优先数。 icp叫做栈外(in coming priority)优先数。 icp叫做栈外 叫做栈外(in priority)优先数 优先数。 操作符优先数相等的情况只出现在括号 操作符优先数相等的情况只出现在 括号 配对或栈底的“ 号与输入流最后的“ 配对或栈底的“;”号与输入流最后的“;” 号配对时 号配对时。
a+b*(c-d)-e^f/g
rst1 rst2 rst3 rst6 rst4 rst5
表达式中相邻两个操作符的计算次序为： 表达式中相邻两个操作符的计算次序为 ： 优先级高的先计算; 优先级高的先计算; 优先级相同的自左向右计算; 优先级相同的自左向右计算; 当使用括号时从最内层括号开始计算 。
C/C++中操作符的优先级 C/C++中操作符的优先级
前缀(prefix)表示 表示 前缀
<操作符 <操作数 <操作数 ，如 +AB； 操作符> 操作数 操作数 操作符 操作数> 操作数>， ；
后缀(postfix)表示 表示 后缀
<操作数 <操作数 <操作符 ，如 AB+； 操作数> 操作数 操作符 操作数 操作数> 操作符>， ；
表达式的中缀表示