表达式求值程序设计说明书

表达式求值问题课程设计一、课程目标知识目标：1. 学生能理解并掌握表达式求值的基本概念和规则，包括运算符优先级、括号的运用等。

2. 学生能够正确构建并简化数学表达式，熟练运用算术运算规则进行求值。

3. 学生能运用所学知识解决实际问题，如根据给定的条件编写表达式，并计算出结果。

技能目标：1. 学生培养逻辑思维能力，通过分析问题，能合理设计表达式并进行求值。

2. 学生通过实际操作，提高解决数学问题的计算速度和准确性。

3. 学生通过小组讨论和问题解决，提升合作能力和交流表达能力。

情感态度价值观目标：1. 学生培养对数学的兴趣，认识到数学在日常生活和未来学习中的重要性。

2. 学生在学习过程中树立正确的价值观，明白诚实求是的科学态度是学习数学的基础。

3. 学生通过解决表达式求值问题，增强自信心，培养勇于尝试和克服困难的积极态度。

课程性质分析：本课程为数学学科，针对五年级学生设计。

该阶段学生具备一定的数学基础和逻辑思维能力，需要通过表达式求值问题进一步巩固算术运算规则，提高解题能力。

学生特点分析：五年级学生处于好奇心强、求知欲旺的时期，他们喜欢探索和解决问题。

但同时，个别学生可能在数学学习上存在困难，需要教师关注并给予个性化指导。

教学要求：1. 教学内容紧密联系课本，确保学生能够掌握基础知识。

2. 教学过程中注重启发式教学，引导学生主动思考、积极参与。

3. 教学评价关注学生的过程表现，鼓励合作与交流，注重培养学生的综合能力。

二、教学内容本课程依据课程目标，结合课本第五章“数的运算”相关内容，组织以下教学大纲：1. 表达式求值基本概念：- 运算符的种类及优先级- 表达式的构成要素- 括号在表达式中的作用2. 算术运算规则：- 加、减、乘、除四则运算- 混合运算的表达式构建与简化- 乘方和开方的运算规则3. 表达式求值方法：- 逐步计算法- 分步骤代入法- 运用算术性质简化表达式4. 实际问题与表达式求值：- 根据实际问题编写表达式- 应用表达式求解问题- 分析实际问题的数量关系教学内容安排与进度：第一课时：表达式求值基本概念及运算符优先级第二课时：算术运算规则及表达式构建第三课时：表达式求值方法及简化技巧第四课时：实际问题与表达式求值的综合应用教材章节关联：《数学》五年级上册第五章“数的运算”：- 第1节 运算顺序与运算定律- 第2节 四则混合运算- 第3节 乘方与开方- 第4节 应用题与表达式求值三、教学方法为有效达成教学目标，本课程将采用以下多样化的教学方法：1. 讲授法：教师通过生动的语言和形象的比喻，对表达式求值的基本概念、运算规则进行讲解，确保学生掌握必要的理论知识。

汇编语言实训课程设计任务书题目：表达式求值程序班级：计算机科学与技术一班学生姓名：赵旭尧学号： 14730141 题目类型：软件工程（R）指导教师：刘树群一．题目简介该设计要求学生使用汇编语言，设计并开发出针对四则运算表达式进行求值的命令行或窗口程序。

通过该题目的设计过程，可以培养学生结构化程序设计的思想，加深对汇编语言基本语言要素和流程结构的理解，针对汇编语言中的重点和难点内容进行训练，独立完成有一定工作量的程序设计任务，同时强调好的程序设计风格。

得到软件工程的综合训练，提高解决实际问题的能力。

二．设计任务1、查阅文献资料，一般在5篇以上；2、通过键盘输入表达式，进行针对整数的“加减乘除”四则运算表达式进行求值，有良好的界面；3、完成软件结构设计和算法设计；4、完成系统的软件开发和测试工作；5、撰写设计说明书；6、做好答辩工作。

三．主要内容、功能及技术指标1、实现功能及指标：①使用Win32的窗口程序模式，实现表达式求值程序及测试界面程序的设计与开发；②支持整数的四则运算、位运算和小括号等；③使用文本框对表达式进行交互式编辑和输出。

2、问题分析及解决方案框架确定：充分地分析和理解问题本身，弄清要求做什么。

在确定解决方案框架过程中，综合考虑系统功能，考虑怎样使系统结构清晰、合理、简单和易于调试。

最后确定每个过程和函数的简单功能，以及过程（或函数）之间的调用关系，并画出函数之间的调用关系图。

3、详细设计和编码：定义相应的存储结构，确定各个函数的算法，并画出流程图，在此基础上进行代码设计，每个明确的功能模块程序一般不超过200行，否则要进一步划分。

4、完成课程设计报告①需求和规格说明：设计题目和问题描述：题目要解决的问题是什么；②设计思路：主要算法思想，程序功能图，函数之间的调用关系图；设计表示：每个函数或过程的功能，列出每个过程或函数所调用的过程或函数，并画出各函数的流程图；详细设计：主要算法的伪代码；③调试报告：调试过程中遇到的主要问题，是如何解决的；对设计和编码的回顾讨论和分析；改进设想；经验和体会等；④程序实现注释；⑤附录：源程序清单和结果。

ＸＸ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；｝五、算法及时间复杂度１、算法:建立两个不同类型得空栈,先把一个‘＃’压入运算符栈。

数据结构课程设计四则运算表达式求值（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 }。

一、设计题目算术表达式的求解二、设计内容给定一个算术表达式，通过程序求出最后的结果。

具体内容如下：(1)从键盘输入要求解的算术表达式；(2)采用栈结构进行算术表达式的求解过程；(3)能够判断算术表达式正确与否；(4)对于错误表达式给出提示；(5)对于正确的表达式给出最后的结果；三、概要设计设计的内容，可以确定所需的模块及模块间调用关系如流程图所示：模块的关系图四、算法描述栈结构进行算术表达式的求解过程，其各个模块的流程图，如下图所示：创建栈出栈栈的索引值index遍历栈设计源代码#include "iostream.h" #include "stdlib.h" #include "math.h" #include "time.h" #define TRUE 1 #define FALSE 0 #define ERROR -1压栈简单的四则运算运算符typedef int Status; //用模板实现的链式结构堆栈类template <class T>class stack{private:struct link{T data; //结点数据域link *next; //下一结点指针link(T Data,link* Next){//结构体构造函数data=Data;next=Next;}}*head; //堆栈顶指针public:stack(); //构造函数(初始化栈)~stack(); //析构函数(销毁栈)void push(T Data); //压栈操作T gettop()const; //取栈顶元素T pop(); //出栈操作T getvalue(int index); //返回栈底开始第INDEX个栈中值void traverse(int n); //遍历栈N个数换行int empty(); //判断栈是否为空，1是，0非int sizeofstack(); //返回栈的大小void clear(); //清空栈};//类模板成员函数的实现template<class T> stack<T>::stack()//构造函数{head=0;}template<class T> stack<T>::~stack()//析构函数{link* cursor=head;while(head){cursor=cursor->next;delete head;head=cursor;}}template<class T>void stack<T>::push(T Data)//压栈操作{head=new link(Data,head);}template<class T>T stack<T>::gettop()const //取栈顶元素{return head->data;}template<class T>T stack<T>::pop() //出栈操作{if(head==0)return 0;T result=head->data;link* oldhead=head;head=head->next;delete oldhead;return result;}template <class T>T stack<T>::getvalue(int index)//返回栈底开始第INDEX个栈中值{link *cursor=head;int i=1;int stacklen=sizeofstack();if(index<=0||index>stacklen)return 0;while(i<=(stacklen-index)){cursor=cursor->next;i++;}return cursor->data;}template <class T> void stack<T>::traverse(int n)//遍历栈{link * cursor=head;int iEnterSign=1; //换行标识while(cursor){cout<<cursor->data<<" ";if(iEnterSign%n==0)cout<<endl;cursor=cursor->next;iEnterSign++;}if((iEnterSign-1)%n!=0)cout<<endl;}template <class T>int stack<T>::empty() //判断栈是否为空，1是，0非{return head==0?1:0;}template <class T>int stack<T>::sizeofstack() //返回栈的大小{int size=0;link *cursor=head;while(cursor){cursor=cursor->next;size++;}return size;}template<class T> void stack<T>:: clear() //清空栈{link *cursor=head;while(cursor&&cursor->next){cursor=cursor->next;delete head;head=cursor;}}int Operator(char ch){if(ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='('||ch==')'||ch=='#')return(TRUE);elsereturn(FALSE);}char Precede(char ch1,char ch2){char ch;switch(ch1){case '+':case '-':{switch(ch2){case '+':case '-':case ')':case '#':ch='>'; break;case '*':case '/':case '(':ch='<';break;}break;}case '*':case '/':{if(ch2=='(')ch='<';elsech='>';break;}case '(':{if(ch2==')')ch='=';elsech='<';break;}case ')':{ch='>';break;}case '#':{if(ch2=='#')ch='=';elsech='<';break;}}return(ch);}int calc(int x,char ch,int y){int z;switch(ch){case '+': z=x+y; break;case '-': z=x-y; break;case '*': z=x*y; break;case '/': if(y!=0)z=x/y;else//z=0;cout<<"分母不能仅为0!"<<endl;break;}return(z);}int middexpression(char *exp) //求解算式表达式{stack<int> *opnd=new(stack<int>);stack<char> *optr=new(stack<char>);char ch=*exp;int x=0,y,z;int result;optr->push('#');while(ch!='#'||optr->gettop()!='#'){if(!Operator(ch)){x=ch-48;opnd->push(x);ch=*++exp;if(ch!='\0'&&!Operator(ch)){cout<<"不符合要求,运算数必须是0~9之间的数"<<endl;exit(0);}}else{switch(Precede(optr->gettop(),ch)){case '<': //栈顶元素优先权低optr->push(ch);ch=*++exp;break;case '=': //脱括号并接收下一字符optr->pop();ch=*++exp;break;case '>': //退栈并将运算结果入栈if(opnd->sizeofstack()<2){cout<<"表达式不合法!"<<endl;exit(0);}x=opnd->pop();y=opnd->pop();z=calc(y,optr->pop(),x);opnd->push(z);x=0;break;}}if(ch=='\0'){cout<<"表达式应该以'#'结束!"<<endl;exit(0);}}result=opnd->pop();if(opnd->empty()&&optr->pop()=='#')return(result);else{cout<<"输入不合法!"<<endl;exit(0);}}void main(void) //程序入口函数{char exp[50];cout<<"数据结构课程设计-请输入算术表达式(以#结束):"<<endl;cin>>exp;cout<<middexpression(exp)<<endl;}五、测试结果及分析运行程序，输入数据及所得结果如下表；通过实际的将程序输入软件中，执行后所列出的表中，并且通过记录的所得的上表可知，给定的一个算术表达式，通过程序所求出来的值是正确的，并且当输入数值出现错误或者是表达式输入错误时，也会给出相应的错误提示，所以程序达到了原先所要的设计的要求。

课程设计报告课程名称数据结构课题名称表达式求值专业计算机科学与技术班级0901学号200903010102姓名覃宇星指导教师李珍辉邓作杰郭芳2011年7月7日湖南工程学院课程设计任务书课程名称C语言程序设计课题表达式求值专业班级计算机0901学生姓名学号指导老师周铁山审批任务书下达日期2011年6月23 日任务完成日期2011年7月7日《数据结构课程设计》一、课程设计的性质和目的数据结构课程设计是计算机专业的专业课程，通过课程设计使学生进一步巩固课堂所学知识，全面熟悉、掌握数据结构的基本设计方法和技巧，进一步提高分析问题、解决问题及上机操作能力，为将来从事计算机工作打下一定的专业基础。

二、设计课题课题一：迷宫问题详细内容见后课题二：马踏遍棋盘问题详细内容见后课题三：表达式求值问题详细内容见后课题四：B+树的实现详细内容见后三、课程设计报告要求课程设计报告每人一份，必须包含如下几个方面的内容：1.基本设计思想；2.主要数据结构；3.主要实施流程；4.所有源代码；5.课程设计总结与体会。

四、分组及选题办法1、一人一组。

2、若选择课题四，则只需完成一题即可；否则，必须至少完成前三个课题中的任意两个。

3、成绩考核按个人课题完成情况、设计报告质量及对课程设计的态度等综合评定。

五、设计进度安排1、讲课及上机调试时间安排：各班具体时间另行安排2、其余时间：查阅资料，确定方案，设计课题相关程序。

3、分组答辩，交课程设计报告。

设计课题三：表达式求值问题一、问题提出在高级语言程序中出现的数学表达式要进行求值运算，本课程设计要求模拟编译程序的求值过程，利用栈这种数据结构，对包含四则算术运算及多重括号及常量的表达式进行求值运算。

二、设计要求1．一次性输入一个表达式，包含数值常量、四则算术运算符、括号等。

2．能输出表达式的正确结果。

1．输入输出界面清晰明了。

三、设计提示1．可用两个栈（操作数栈和运算符栈）来存储运算过程中的原始数据及中间结果。

程序设计实训报告—表达式求值问题完成者：何炜班级：计科1501学号：完成日期：2016年7月14日星期四目录一、题目的内容及要求................................. 错误!未定义书签。

二、需求分析 ................................................ 错误!未定义书签。

三、概要设计 ................................................ 错误!未定义书签。

四、详细设计 ................................................ 错误!未定义书签。

五、源代码 .................................................... 错误!未定义书签。

六、运行结果及分析..................................... 错误!未定义书签。

七、收获及体会............................................. 错误!未定义书签。

一、题目的内容及要求求解形如（a+b)*((c+d)*e+f*h*g)的简单算术表达式的求值问题。

这种表达式只包括加、减、乘、除4种运算符。

为了实现表达式求值，可以首先读入原表达式（包括括号）并创建对应二叉树，其次对二叉树进行前序遍历、中序遍历、后续遍历（非递归），并输出逆波兰表达式，最后求解原表达式的值，同时对非法表达式格式能予以判断。

用二叉树的结构来存储表达式，后续遍历二叉树即可得到逆波兰表达式二、需求分析本程序能解决形如（a+b)*((c+d)*e+f*h*g)并以’#’作为结束标志的简单算术表达式的求值问题。

不仅能够求解出多位浮点数，而且能够对简单的非法表达式进行判断以避免程序异常退出。

三、概要设计1.用户输入中缀表达式2.程序将中缀表达式用二叉树的链式存储结构存储下来3.前序、中序遍历这颗二叉树，输出对应的前缀、中缀表达式4.后续遍历（非递归）这颗二叉树，并把遍历结果存储在顺序栈内，并输出后缀表达式5.对后缀表达式进行求值四、详细设计以下对概要设计进行详细的原理分析。

表达式求值(数据结构) 表达式求值(数据结构)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. 学生能理解并掌握表达式求值的基本概念和方法。

2. 学生能运用算术运算规则，正确进行整式和分式的求值。

3. 学生了解代数式中字母所表示的含义，能进行简单的代数式求值。

技能目标：1. 学生能运用所学知识解决实际问题，构建并简化表达式。

2. 学生通过练习，提高逻辑思维能力和解决问题的能力。

3. 学生学会使用计算器或其他工具进行表达式求值，提高计算速度和准确性。

情感态度价值观目标：1. 学生培养对数学的兴趣，认识到数学在生活中的重要性。

2. 学生在合作学习中培养团队精神和沟通能力，学会尊重他人意见。

3. 学生在解决问题过程中，培养勇于尝试、克服困难的信心和毅力。

课程性质：本课程为初中数学表达式求值部分，强调理论与实践相结合，注重培养学生的计算能力和逻辑思维能力。

学生特点：学生处于初中阶段，具有一定的数学基础和逻辑思维能力，但个别学生可能对数学存在恐惧心理，需要鼓励和引导。

教学要求：结合学生特点，采用启发式教学，引导学生主动参与课堂，通过实例讲解、练习巩固、拓展提高等环节，帮助学生掌握表达式求值的方法和技巧。

同时，关注学生的情感态度，激发学生的学习兴趣，培养良好的学习习惯。

在教学过程中，将课程目标分解为具体的学习成果，便于教学设计和评估。

二、教学内容1. 表达式求值的基本概念：通过课本第二章第三节的内容，讲解表达式求值的定义和意义，使学生理解表达式求值在数学中的应用。

- 整式求值：介绍整式的组成，以及如何代入数值进行求值。

- 分式求值：讲解分式的性质，以及如何代入数值计算分式的值。

2. 算术运算规则的应用：结合课本第二章第四节，复习加减乘除等基本运算规则，并应用于表达式求值。

- 运算顺序：强调运算顺序对求值结果的影响，介绍括号的使用。

3. 代数式求值：利用课本第二章第五节，引导学生理解代数式中字母的含义，并进行简单的代数式求值。

- 代数式的代入：学会将字母代表的数值代入代数式中进行求值。

实验报告二表达式求值一、问题描述1.实验题目：表达式求值2.基本要求：输入一个算术表达式，输出其值。

3.测试数据：表达式为：1.5+（2-3）*2# (#表示结束)运行结果应为：-0.500000二、需求分析1. 本程序用来求任意一个由浮点型数据和加减乘除四则运算构成的简单算术表达式的值。

2. 用户根据程序运行后的提示信息输入算术表达式，运算符仅限+-*/，操作数仅限浮点数，表达式以#结尾表示结束。

3. 用户输入完毕后，程序自动输出运算结果。

三、设计核心算法：采用算符优先算法，使用两个工作栈，一个称为OPTR，用来存放运算符；另一个称为OPND，用来寄放操作数或运算结果。

算法的基本思想是：（1）首先置操作数为空栈，表达式起始符"#"为运算符栈的栈底元素；（2）依次读入表达式中的每个字符，若是操作数则进OPND栈，若是运算符则和OPTR栈的栈顶元素比较优先权后作相应操作，直至整个表达式求值完毕（输入为"#"）.四、测试结果五、附录//表达式求值#include <stdio.h>#include <stdlib.h>#include <string.h>#define error 0#define ok 1#define overflow -1#define STACK_INIT_SIZE 100#define STACKINCREMENT 10#define OPSETSIZE 7char OPSET[OPSETSIZE]={'+','-','*','/','(',')','#'}; unsigned char Prior[7][7] = { // 算符间的优先关系'>','>','<','<','<','>','>','>','>','<','<','<','>','>','>','>','>','>','<','>','>','>','>','>','>','<','>','>','<','<','<','<','<','=',' ','>','>','>','>',' ','>','>','<','<','<','<','<',' ','='};typedef int Status;template <typename T>struct SqStack{T *top;T *base;int stacksize;};//顺序栈结构模板template <typename T1,typename T2>Status InitStack(T1 &S){S.base=(T2 *)malloc(STACK_INIT_SIZE*sizeof(T2));if(!S.base) exit (overflow);S.top=S.base;S.stacksize=STACK_INIT_SIZE;return ok;}//初始化栈函数模板template <typename T1,typename T2>Status Push(T1 &S,T2 e){if(S.top-S.base>=S.stacksize){S.base=(T2 *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(T2));if(!S.base) exit (overflow);S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return ok;}//入栈函数模板template <typename T1,typename T2>Status Pop(T1 &S,T2 &e){if(S.top==S.base) return error;e=*--S.top;return ok;}//出栈函数模板template <typename T1,typename T2>T2 GetTop(T1 S){if(S.top==S.base)return error;elsereturn *(S.top-1);}//获取栈顶元素模板Status In(char Test,char* TestOp) {bool Find=false;for (int i=0; i< OPSETSIZE; i++) {if (Test == TestOp[i]) Find= true;}return Find;}//判断是否为运算符float Operate(float a,unsigned char theta, float b) {switch(theta) {case '+': return a+b;case '-': return a-b;case '*': return a*b;case '/': return a/b;default : return 0;}}//运算int ReturnOpOrd(char op,char* TestOp) {int i;for(i=0; i< OPSETSIZE; i++) {if (op == TestOp[i]) return i;}return 0;}char precede(char Aop, char Bop) {return Prior[ReturnOpOrd(Aop,OPSET)][ReturnOpOrd(Bop,OPSET)];}//ReturnOpOrd和precede组合，判断运算符优先级float EvaluateExpression() {// 算术表达式求值的算符优先算法。

表达式求值课程设计1. 项目背景表达式求值是计算机科学中一个重要的基础概念，也是众多编程语言中必不可少的组成部分。

表达式求值的过程可以理解为将一个表达式中包含的运算符和操作数按照一定的规则进行计算，最终得到一个结果。

在计算机编程中，表达式求值广泛应用于各种场景，例如变量赋值、函数调用、循环控制、条件判断等。

2. 项目目标本课程设计旨在实现一个表达式求值器，能够解析和求值各种形式的表达式。

表达式求值器的主要功能包括：•支持多种运算符，包括算术运算符、逻辑运算符、关系运算符等。

•支持多种操作数，包括常量、变量、函数调用等。

•支持括号，以便对表达式进行分组。

•支持各种表达式，包括算术表达式、逻辑表达式、关系表达式等。

3. 项目实现表达式求值器可以按照以下步骤实现：1.词法分析：将表达式字符串解析为一系列标记（token），每个标记代表一个运算符、操作数或括号。

2.语法分析：将标记序列解析为一个语法树，语法树代表表达式的结构。

3.语义分析：对语法树进行语义检查，确保表达式是合法的。

4.代码生成：将语法树转换为计算机可以执行的代码。

5.代码执行：执行生成的代码，得到表达式的值。

4. 项目测试表达式求值器可以按照以下方法进行测试：1.单元测试：编写单元测试用例，测试表达式求值器的各种功能。

2.集成测试：将表达式求值器集成到其他程序中，测试表达式求值器在实际应用中的表现。

3.性能测试：测试表达式求值器的性能，包括执行速度和内存消耗等。

5. 项目总结表达式求值器是一个重要的计算机科学基础项目，可以帮助学生理解表达式求值的过程和原理，并掌握表达式求值器如何实现。

本项目设计实现了表达式求值器，支持多种运算符、操作数和表达式，并通过单元测试、集成测试和性能测试对表达式求值器进行了全面的测试。

通过本项目设计，学生可以提高自己的编程能力和对表达式求值原理的理解。

OPTR->top--;
}
double Calculate(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;
void PushNum(OPND *OPND,double num){ //操作数进栈
OPND->top++;
OPND->array[OPND->top-1]=num;
}
void PopNum(OPND *OPND,double *num){ //操作数出栈
*num=OPND->array[OPND->top-1];
default:priority='E';
}
return priority;
}
void Process(OPND *OPND,OPTR *OPTR,char x){ //计算表达式
double a,b;char c;
static double tempnum=0.00000000;
static int len=10; //用于各数位上的值的转换
double array[N];
int top;//栈顶指针
}OPND;
typedef struct{ //定义运算符栈
char array[N];
int top;//栈顶指针
}OPTR;
int Cint(char mychar){ //将字符0-9转换成数值

表达式求值的课程设计一、课程目标知识目标：1. 理解并掌握算术表达式的组成要素，包括运算符、变量和常量。

2. 学会运用算术运算规则，正确进行表达式的求值。

3. 掌握基本的算术优先级原则，并能运用到复杂的表达式求值中。

技能目标：1. 能够根据给定的算术表达式，准确地识别各组成元素及其作用。

2. 能够运用所学知识，完成简单到复杂算术表达式的求值，包括整数和小数的混合运算。

3. 能够分析并解决求值过程中出现的问题，提高逻辑思维和问题解决能力。

情感态度价值观目标：1. 培养学生对数学表达式的兴趣，激发学习数学的热情。

2. 培养学生细心、耐心和严谨的学习态度，对待每个求值步骤都能认真负责。

3. 培养学生的合作意识，通过小组讨论和交流，共同解决问题，提高团队协作能力。

分析课程性质、学生特点和教学要求，将目标分解为具体学习成果：1. 通过课堂讲解和实例分析，确保学生理解算术表达式的组成和求值规则。

2. 通过课堂练习和课后作业，让学生掌握不同类型的算术表达式的求值方法。

3. 通过小组讨论和问题解答，培养学生主动思考、合作解决问题的能力。

4. 结合实际情境，设计有趣的教学活动，提高学生对数学学科的兴趣和热情。

本节教学内容围绕算术表达式的求值，依据课程目标进行选择和组织。

主要包括以下几部分：1. 算术表达式的组成：介绍表达式中的运算符、变量和常量的概念，让学生了解各元素在表达式中的作用。

2. 算术运算规则：讲解加、减、乘、除等基本运算的法则，以及运算的优先级原则。

3. 表达式求值方法：教授从左到右的求值顺序，以及括号改变运算优先级的方法。

4. 混合运算表达式求值：涵盖整数、小数和分数的混合运算，使学生掌握不同类型数据的运算规则。

5. 复杂表达式求值：引导学生运用所学知识解决包含多个运算符和括号的复杂表达式的求值问题。

教学内容安排和进度：第一课时：算术表达式的组成、基本运算规则及优先级原则。

第二课时：简单表达式的求值方法，以及混合运算表达式的求值。

**大学数据结构课程设计说明书学生姓名:***学号： **********学院: **********学院专业: 网络工程题目: 利用栈求表达式的值成绩指导教师******2009 年 7 月 9 日1．设计目的数据结构课程设计的目的是，通过设计掌握数据结构课程中学到的基本理论和算法并综合运用于解决实际问题中，它是理论与实践相结合的重要过程。

设计要求学会如何对实际问题定义相关数据结构，并采用恰当的设计方法和算法解决问题，同时训练学生进行复杂程序设计的技能和培养良好的程序设计习惯。

2．设计内容和要求利用栈求解表达式的值。

设计内容：1)建立试题库文件，随机产生n个题目；2)题目涉及加减乘除，带括弧的混合运算；3)利用栈求解表达式的值；4)随时可以退出；5)保留历史分数，能回顾历史，给出与历史分数比较后的评价基本要求：1)系统功能的完善；2)代码中有必要的注释3．本设计所采用的数据结构栈的数组表示方法（静态分配整型指针）typedef struct{typedef data[MAXSIZE];int top;};4．功能模块详细设计1.功能一：中缀表达式转化为后缀表达式；2.功能二：后缀表达式求值；3.功能三：文件读写；4.功能四：作业评分；5.功能五：历史成绩本次成绩比较；6.功能六：输入“~”符号退出程序4.1 详细设计思想1.首先实现表达式的求值：要用栈求解一个表达式,就要将这个表达式翻译成正确求值的一个机器指令序列,即正确解释表达式,了解算术四则混合运算的规则：(1).先乘除,后加减;(2).从左算到右;(3).先括号内,后括号外再根据这个运算优先的规定来实现对表达式的编译或解释执行.任何一个表达式都是由操作数(st)和操作符(op)组成的，根据四则运算基本法则，在运算的每一步中，任意两个相继出现的操作符op1和op2之间的优先关系最多有以下3种：(1).op1的优先级低于op2(2).op1的优先级等于op2(3).op1的优先级小于op2为实现运算符优先，可以使用两个操作栈，操作栈st,用于存放操作数及运算结果；操作栈op，用于存放操作符。

数据结构（C语言版）课程设计报告表达式求值说明书XX大学数据结构课程设计说明书题目:表达式求值院系：计算机科学与工程学院专业班级：计算机班学号：学生姓名：指导教师：2021年X月X日XX大学课程设计（论文）任务书计算机科学与工程学院学号学生姓名专业（班级）设计题目表达式求值设计技术参数系统平台：Windows7/WindowsXP开发工具：VC++6.0设计要求（1）能够计算的运算符包括：加、减、乘、除、圆括号。

（2）能够计算的数要求在实数范围内。

（3）能执行多重括号嵌套运算。

（4）对于异常表达式给出错误提示。

工作量课程设计报告要求不少于3000字。

源程序要求不少于300行工作计划2021.11.21-12.01根据课程设计大纲的要求，查找相关资料，完成需求分析；2021.12.02-12.16进行系统的概要设计；2021.12.17-12.31进行系统的详细设计和源代码的书写；2021.01.01-01.17对系统进行调试分析，写出课程设计报告。

参考资料[1]何钦铭主编.C语言程序设计.北京：高等教育出版社,2021.[2]谭浩强编著.C程序设计（第四版）.北京：清华大学出版社,2021.[3]严蔚敏,吴伟民编著.数据结构（C语言版）北京：清华大学出版社,2021.[4]严蔚敏,吴伟民编著.数据结构题集北京：清华大学出版社,2021.指导教师签字教研室主任签字2021年X月X日学生姓名：学号：专业班级：课程设计题目：表达式求值指导教师评语：成绩：指导教师：年月日XX大学课程设计（论文）成绩评定表目录1需求分析12概要设计12.1设计思路12.2存储结构设计12.3功能模块设计13详细设计14运行与测试15总结1参考文献2(要求：给出一级目录和二级目录，宋体，四号字,1.5倍行距，页码使用罗马数字，居中)（报告正文部分）：(要求：正文部分一律用小四号字，宋体，行距20磅。

一级标题靠左，加粗。

二级大标题靠左，不加粗。

数据结构课程设计报告设计题目：表达式求值年级05级班级姓名学号指导教师起止时间2007.11.26—11.302007 年第一学期一．实习目的通过实习，了解并初步掌握设计、实现较大系统的完整过程，包括系统分析、编码设计、系统集成、以及调试分析，熟练掌握数据结构的选择、设计、实现以及操作方法，为进一步的应用开发打好基础。

二．问题描述一个算术表达式是由操作数(operand)、运算符(operator)和界限符(delimiter)组成的。

假设操作数是正整数，运算符只含加减乘除等四种运算符，界限符有左右括号和表达式起始、结束符“#”，如：#（7+15）*（23-28/4）#。

引入表达式起始、结束符是为了方便。

编程利用“算符优先法”求算术表达式的值。

三．需求分析为实现算符优先算法,可以使用两个工作栈。

一个称做OPTR，用以寄存运算符;另一个称做OPND;用以寄存操作数或运算结果。

算法的基本思想是：1) 首先置操作数栈为空栈，表达式起始符“#”为运算符栈的栈底元素;2) 依次读入表达式中每个字符,若是操作数则OPND栈,若是运算符,则和OPTR栈的栈顶运算符比较优先权后做相应操作,直至整个表达式求值完毕(即OPTR栈的栈顶元素和当前读入的字符均为"#")。

该程序实现表达式的求值问题：（1）从键盘读入一个合法的算术表达式，利用算符优先关系，实现对算术四则混合运算的求值，输出正确的结果。

（2）显示输入序列和栈的变化过程。

四．概要设计•程序流程图:•系统用到的抽象数据类型定义：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。

实验四算术表达式求值运算器一、实验目的帮助学生熟练掌握栈的基本操作，并通过用算符优先法对表达式求值的过程深刻领会用栈解决实际问题的基本方法。

二、实验内容编写程序实现从键盘终端输入语法正确的算术表达式，计算出表达式的值。

为了避免算符的二义性，可以假设表达式中只包含实型正常数运算符包括加、减、乘、除四种基本运算，可以包含圆括号。

三、实验仪器微型计算机实验用编程语言：Turbo C 2.0，Borland C 3.0等以上版本四、实验原理1、算术四则运算法则：先乘除后加减从左至右先括号内后括号外2、方法：对运算符建立优先关系矩阵，按优先关系对表达式进行处理。

算符：运算符和界符。

根据法则1：对于两个相邻运算符，乘除优先于加减。

根据法则2：乘除优先级相同，加减优先级相同。

相邻两个同级运算符左优先。

根据法则3：“（”前面的运算符优先级低于“（”的优先级。

“（”的优先级低于右边相邻算符。

“）”左边的算符高于“）”的优先级。

由于“（”和“）”必须成对出现，令它们的优先性相同。

为了处理的方便，假设表达式以“＃”开始和结束，输入表达式的一般形式为：#表达式#如：#5.3+4.2*(7.6+4.5)#规定开始的“＃”的优先性低于所有其它算符，所有其它算符的优先性高于结束的“＃”。

根据假设，表达式开始的“#”和结束的“#”必须成对出现，所以也令它们的优先性相同。

对于一个正确的表达式，“)”不可能与“（”相邻，“（”不可能与结束的“#”相邻，开始的“#”不可能与“）”相邻，它们之间没有优先性，程序应具有这种判断能力。

根据上面的讨论，可用表1所示的算符优先关系矩阵来描述算符之间的优先关系，其中，用“>”表示表达式中前一个算符的优先性高于后一个算符的优先性，用“<”表示表达式中前一个算符的优先性低于后一个算符的优先性，用“=”表示表达式中前一个算符的优先性与后一个算符的优先性相同。

若两个算符之间无优先性，用空白表示。