表达式求值课程设计

合集下载

表达式求值问题课程设计

表达式求值问题课程设计

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

算术表达式的求解-数据结构课程设计报告

算术表达式的求解-数据结构课程设计报告

算术表达式的求解-数据结构课程设计报告课程设计报告题目:算术表达式求值一、需求分析 1、设计要求:给定一个算术表达式,通过程序求出最后的结果 1>、从键盘输入要求解的算术表达式; 2>、采用栈结构进行算术表达式的求解过程; 3>、能够判断算术表达式正确与否;4>、对于错误表达式给出提示;5>、对于正确的表达式给出最后的结果; 2、设计构想:为了实现算符优先算法使用两个工作栈,一个称作OPTR,以寄存运算符;另一个称作OPND,用以寄存操作数或运算结果。

在操作数和操作符入栈前,通过一个函数来判别,输入的是操作数还是操作符,操作数入OPND,操作符入OPTR。

在输入表达式的最后输入‘#’,设定‘#’的优先级最低,代表表达式输入结束。

在表达式输入过程中,遇操作数则直接入栈,遇到运算符则与栈顶运算符比较优先级,若当前运算符优先级高,则当前运算符入栈,扫描下一符号;否则栈顶运算符出栈,两操作数出栈,进行运算,所得结果入数栈,重新比较当前运算符与新栈顶运算符。

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

二、概要设计1、本程序包含的模块:栈模块——实现栈抽象数据类型运算模块——实现数据表达式的运算主程序模块算术运算式的求解栈模块主函数模块main 运算模块定义栈结构初始化栈出栈入栈取栈顶元素判断输入字符类型判断符号优先级基础运算函数运算函数三、详细设计栈模块1、定义栈结构 struct Sqstack{elemtype *top;//栈顶元素 elemtype *base; //栈底元素 int stacksize;//栈的大小 };2、栈的基本操作①初始化栈status initstack(struct Sqstack &s) {=(elemtype *)malloc(stack_size*sizeof(elemtype)); if(!) return OVERFLOW; =;=stack_size; return OK; } ②入栈status push(struct Sqstack &s,elemtype e) {if(>=) {=(elemtype*)realloc(,(+stack_increasement)*sizeof(elemtype));if(! ) return OVERFLOW; =+; +=stack_increasement; } * ++=e; return OK; } ③出栈elemtype pop(struct Sqstack &s) {elemtype e; if(= =) return ERROR; e=*--;return e; }④取栈顶元素elemtype gettop(struct Sqstack &s) {elemtype e; if(==) return ERROR; e=* ; return e; } 运算模块1、判断输入字符c是否为操作符:若是,则返回1;否则,返回0 int In(int c) {char p[10]=\ int i=0;while(p[i]!='\\0') {if(p[i]==c) return 1;i++; } return 0; }2、判断运算符的优先级char precede(char top,char c)//该函数为判断当前运算符与前一个运算符的优先级,前一个运算符高于或等于当前运算符的优先级则返回‘>’,前一个运算符小于当前运算符的优先级则返‘'; break; case '+': case '-':if(top=='#'||top=='(')result=''; break; case '*': case '/':if(top=='*'||top=='/'||top=='^') result='>'; elseresult=''; elseresult=''; break;case '(': result='': theta=pop(optr); b=pop(opnd); a=pop(opnd); push(opnd,operate(a,theta,b)); break;// 若当前操作符的优先级低于操作符栈的栈顶元素,则将操作符栈栈顶元素出栈,并将操作数栈的栈顶两个元素出栈,计算两个元素间以操作符栈栈顶元素为运算符的数学运算}//switch }//if}//whilereturn pop(opnd); }主程序模块1、main函数void main(int argc,char *argv) {struct Sqstack opnd; //操作数栈 struct Sqstack optr;//操作符栈initstack(opdn); initstack(optr); elemtype result;printf(\ printf(\算术运算式的求解\printf(\ printf(\请输入算术运算表达式(以'#'结尾):\\n\ printf(\result=evaluate(opnd,optr);printf(\printf(\运算的结果是 :\\n \\n%d\\n\printf(\}四、调试分析 1、测试结果1> 测试数据:3+7*2-1# 测试结果:2> 测试数据:(3+7)*2-1# 测试结果:3> 测试数据: 1/0# 测试结果:2、程序时间复杂度为O;3、设计中出现的问题:在开始的设计中没有注意除数不能为0 ,后来加入if(b==0) {printf(\分母为0,the result is error\\n\ result=0; } elseresult=a/b;break;来判断除数是否为0 4、算法改进:1>输入的操作数和操作码于是字符串类型的,在原设计中实现的操作都是对个位数实现的,实用性不大,故在后来的设计中,通过一个标志flag实现了标志操作数的连续输入的判别,继而实现了多位数的表达式运算2>开始只实现了加、减、乘、除及带小括号的数学运算,考虑到实用性,在后来的设计中引入pow函数,实现了乘方的运算,调整结果如下:3>最初设计的运行界面过于单调,不够友好,改进时加入一些*调整调整结果如下:五、课程设计总结本学期是我第一次接触课程设计,发现了很多学习上的问题,也有很多收获。

数据结构课程设计- 算术表达式求值

数据结构课程设计- 算术表达式求值

课程设计报告课程名称数据结构课程设计题目算术表达式求值指导教师设计起始日期 4.18~4.25学院计算机学院系别计算机科学与工程学生姓名班级/学号成绩一、需求分析设计一个算术表达式四则运算的程序,要求完成包括加、减、乘、除运算,包含括号的基本整数表达式的运算。

在这里运算数可以1位长度,也可以多位长度。

在运算之后输出的正确运算结果,输入表达式后演示在求值中运算数栈内的栈顶数据变化过程,最后得到运算结果。

(1)输入:3*(7-2)(2)输出:数据栈栈顶元素:3,7,2,7,5,3,15结果:15(3)自选数据二、概要设计1、使用栈的数据结构表示数据的存储。

2、设计算法将中缀表达式转换成后缀表达式,用栈的数据结构实现表达式的运算。

3、把中缀表达式转换为后缀表达式算法的基本思路是从头到尾地扫描中缀表达式中的每个字符,对于不同类型的字符按不情况进行处理。

三、详细设计数据结构:字符类型栈/* 定义字符类型栈*/typedef struct{char stackname[20];char *base;char *top;} Stack;算法:将中缀表达式转换为后缀表达式void Change(char* s1, char* s2)// 将字符串s1中的中缀表达式转换为存于字符串s2中的后缀表达式{Stack R; // 定义用于暂存运算符的栈InitStack(R); // 初始化栈Push(R,'#'); // 给栈底放入’#’字符,它具有最低优先级0int i,j;i=0; // 用于指示扫描s1串中字符的位置,初值为0j=0; // 用于指示s2串中待存字符的位置,初值为0char ch=s1[i]; // ch保存s1串中扫描到的字符,初值为第一个字符while( ch!='#'){ // 顺序处理中缀表达式中的每个字符if(ch==' ')// 对于空格字符不做任何处理,顺序读取下一个字符ch=s1[++i];else if(ch=='('){ // 对于左括号,直接进栈Push(R,ch);ch=s1[++i];}else if(ch==')'){ // 对于右括号,使括号内的仍停留在栈中的运算符依次// 出栈并写入到s2中while(Peek(R)!='(')s2[j++]=Pop(R);Pop(R); // 删除栈顶的左括号ch=s1[++i];}else if(ch=='+'||ch=='-'||ch=='*'||ch=='/'){ // 对于四则运算符,使暂存在栈中的不低于ch优先级// 的运算符依次出栈并写入到s2中char w=Peek(R);while(Precedence(w)>=Precedence(ch)){ // Precedence(w)函数返回运算符形参的优先级s2[j++]=w;Pop(R); w=Peek(R); }}四、调试分析调试:在设计过程中出现程序不能运行,发现不能找到结束标识符,因此在设计的时候需要人为动态添加结束标识符‘#’,顺利运行算法时间和空间分析:算法的运行时间主要花在while循环上,它从头到尾扫描后缀表达式中的每一个数据(每个操作数或运算符均为一个数据),若后缀表达式由n个数据组成,则此算法的时间复杂度为O(n)。

数据结构课程设计报告-表达式求值

数据结构课程设计报告-表达式求值

《数据结构》课程设计利用栈求表达式的值班级: 2学号: 100171021330姓名:吴迪指导老师:王方利用栈求表达式的值1、设计思路这个程序的关键是对数字与运算符的判断和运算符优先级的判断,以及出栈的运算。

建立两个栈,分别存储数字与运算符,栈1存运算符,栈2存数字。

依次读取表达式的字符串,先判断是数字还是运算符,如果是数字不能马上压入栈2,因为可能是大于10的数字,应该继续循环,如果还是数字,则利用计算保存数值,直到指到运算符时停止,将计算后的数字压入栈2。

压入运算符之前先将要压入的与栈顶的运算符优先级相比较,如果栈顶是‘(’而当前不是‘)’,则不需比较优先级,直接压入;如果栈顶是‘(’,当前是‘)’,则抵消(弹出‘(’,指向表达式下一个字符);若当前的运算符优先级大于栈顶的,则压入;若当前的运算符优先级小于栈內时,弹出栈顶的运算符,同时弹出两组数字,经过运算符的运算后再重新压到栈内。

为了方便判断运算结束,在存储运算符之前先将‘#’压入栈1中,在输入表达式时以‚#‛结束,所以可以以运算符==‘#’并且栈1顶==‘#’来结束运算,弹出栈2的数值,即为表达式求值的最终结果。

上述操作的算法步骤:(1)初始化算符S1,数字栈S2;,将‘#’压入算符栈S1中。

(2)读表达式字符=>w。

(3)当栈顶为‘#’并且w也是‘#’时结束;否则循环做下列步骤:(3-1)如果w是数字,存储到m,再经过计算存储到num中。

m=w-‘0’;num=num*pow(10,n)+m;n++;读下一个字符=>w,如果是运算符,则跳出循环;转3-2。

(3-2)w若是运算符,则:(3-2-1)如果栈顶为‘(’并且w为‘)’则‘(’出栈,读下一个字符=>w;转(3)。

(3-2-2)如果栈顶为‘(’或者栈顶优先级小于w优先级,则w入栈,读下一个字符=>w;转(3)。

否则:从算符栈中出栈,并从数字栈中弹出两组数字进行运算,将结果重新压入数字栈,转(3)。

数据结构课程设计-表达式求值【完整版】

数据结构课程设计-表达式求值【完整版】

XXXXXX大学《数据结构》课程设计报告班级:学号:姓名:指导老师:目录一算术表达式求值一、需求分析二、程序得主要功能三、程序运行平台四、数据结构五、算法及时间复杂度六、测试用例七、程序源代码二感想体会与总结算术表达式求值一、需求分析一个算术表达式就是由操作数(operand)、运算符(operator)与界限符(delimiter)组成得。

假设操作数就是正整数,运算符只含加减乘除等四种运算符,界限符有左右括号与表达式起始、结束符“#”,如:#(7+15)*(23—28/4)#。

引入表达式起始、结束符就是为了方便.编程利用“算符优先法”求算术表达式得值.二、程序得主要功能(1)从键盘读入一个合法得算术表达式,输出正确得结果。

(2)显示输入序列与栈得变化过程。

三、程序运行平台Visual C++6、0版本四、数据结构本程序得数据结构为栈。

(1)运算符栈部分:struct SqStack //定义栈{char *base; //栈底指针char *top; //栈顶指针intstacksize; //栈得长度};intInitStack (SqStack &s) //建立一个空栈S{if (!(s、base= (char *)malloc(50*sizeof(char))))exit(0);s、top=s、base;s、stacksize=50;return OK;}char GetTop(SqStack s,char &e) //运算符取栈顶元素{if (s、top==s、base) //栈为空得时候返回ERROR{ﻩ printf("运算符栈为空!\n");ﻩ return ERROR;}elsee=*(s、top-1); //栈不为空得时候用e做返回值,返回S得栈顶元素,并返回OK returnOK;}int Push(SqStack&s,char e) //运算符入栈{if (s、top—s、base >= s、stacksize)ﻩ{printf("运算符栈满!\n");ﻩs、base=(char*)realloc(s、base,(s、stacksize+5)*sizeof(char));//栈满得时候,追加5个存储空间if(!s、base)exit (OVERFLOW);s、top=s、base+s、stacksize;s、stacksize+=5;}ﻩ*(s、top)++=e;//把e入栈ﻩreturn OK;}int Pop(SqStack &s,char &e) //运算符出栈{if (s、top==s、base) //栈为空栈得时候,返回ERROR{printf("运算符栈为空!\n”);ﻩ return ERROR;}else{ﻩﻩe=*-—s、top;//栈不为空得时候用e做返回值,删除S得栈顶元素,并返回OK return OK;}}int StackTraverse(SqStack&s)//运算符栈得遍历{ﻩchar *t;ﻩt=s、base;ﻩif (s、top==s、base){ﻩ printf(”运算符栈为空!\n”); //栈为空栈得时候返回ERRORreturn ERROR;}while(t!=s、top){ﻩﻩprintf(" %c",*t); //栈不为空得时候依次取出栈内元素t++;ﻩ}return ERROR;}(2)数字栈部分:struct SqStackn//定义数栈{int *base; //栈底指针int*top; //栈顶指针int stacksize; //栈得长度};intInitStackn (SqStackn &s) //建立一个空栈S{s、base=(int*)malloc(50*sizeof(int));if(!s、base)exit(OVERFLOW);//存储分配失败s、top=s、base;s、stacksize=50;return OK;}int GetTopn(SqStackn s,int&e) //数栈取栈顶元素{if(s、top==s、base){printf("运算数栈为空!\n");//栈为空得时候返回ERRORﻩ return ERROR;}elseﻩe=*(s、top-1);//栈不为空得时候,用e作返回值,返回S得栈顶元素,并返回OKreturnOK;}int Pushn(SqStackn &s,int e) //数栈入栈{if(s、top—s、base>=s、stacksize){ﻩﻩprintf("运算数栈满!\n");//栈满得时候,追加5个存储空间ﻩs、base=(int*)realloc (s、base,(s、stacksize+5)*sizeof(int));if(!s、base) exit (OVERFLOW);ﻩs、top=s、base+s、stacksize;//插入元素e为新得栈顶元素s、stacksize+=5;}*(s、top)++=e; //栈顶指针变化returnOK;}int Popn(SqStackn &s,int &e)//数栈出栈{ﻩif (s、top==s、base){ﻩ printf("运算符栈为空!\n");//栈为空栈得视时候,返回ERRORﻩ return ERROR;ﻩ}else{ﻩﻩe=*—-s、top;//栈不空得时候,则删除S得栈顶元素,用e返回其值,并返回OK ﻩreturnOK;}}int StackTraversen(SqStackn &s)//数栈遍历{ﻩint*t;ﻩt=s、base ;ﻩif(s、top==s、base)ﻩ{printf("运算数栈为空!\n”);//栈为空栈得时候返回ERRORﻩ return ERROR;ﻩ}ﻩwhile(t!=s、top)ﻩ{printf(” %d”,*t); //栈不为空得时候依次输出t++;}return ERROR;}五、算法及时间复杂度1、算法:建立两个不同类型得空栈,先把一个‘#’压入运算符栈。

数据结构课程设计四则运算表达式求值(C语言版)

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

数据结构课程设计之算术表达式求值

数据结构课程设计之算术表达式求值

1【实验题目及要求】[问题描述]一个算术表达式是由操作数(operand)、运算符(operator)和界限符(delimiter)组成的。

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

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

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

[基本要求](1)从键盘或文件读入一个合法的算术表达式,输出正确的结果。

(2)显示输入序列和栈的变化过程。

(3)考虑算法的健壮性,当表达式错误时,要给出错误原因的提示。

(4) 实现非整数的处理(可选功能)。

2【源代码(C语言)】#include<stdio.h>#include<stdlib.h>#include<string.h>#define MAXSIZE 20#define OK 1#define ERROR 0#define OVERLOW 0#define YES 1#define NO 0typedefstruct{char * base;char * top;int stacksize; //最大存储量}OPTR; //字符存储栈typedefstruct{float *base;float *top;int stacksize; //最大存储量}OPND; //数值存储栈int InitOptrStack(OPTR *); //字符栈初始化函数int OptrPush(OPTR *, char); //进字符栈操作int OptrPop(OPTR*, char *); //出字符栈操作int OptrEmpty(OPTR ); //判断字符栈是否为空char GetOptrTop(OPTR); //返回字符栈顶元素int InitOpndStack(OPND *); //数值栈初始化函数int OpndPush(OPND *, float); //进数值栈操作int OpndPop(OPND*, float*); //出数值栈操作int OpndEmpty(OPND ); //判断数值栈是否为空int JudgeChar(char); //判断是否为字符float GetFloat(char *); //接收一个数字char Precede(char, char); //判断优先级操作float Caculate(float,float,char);//计算数值{char ch, noMean, ci;float num, number1, number2;OPTR optr;OPND opnd;//system("color 30");InitOptrStack(&optr);InitOpndStack(&opnd);while(1){printf(" 请输入表达式以“#”开始,以“#”结束\n ");do{ch = getchar();}while(ch !='#'); //忽略前面非‘#’字符OptrPush(&optr, ch);ch = getchar();while(ch != '#' || GetOptrTop(optr) != '#'){if(!JudgeChar(ch)){ //如果输入的是数字num = GetFloat( &ch );OpndPush(&opnd, num);else{ //输入的是字符switch(Precede(GetOptrTop(optr),ch)){case'<':OptrPush(&optr,ch); //栈顶优先级低ch = getchar();break;case'=':OptrPop(&optr,&noMean); //左右括号,把左括号出栈ch = getchar ();break;case'>': //栈顶优先级高if(OpndPop(&opnd, &number2) && OpndPop(&opnd,&number1)){OptrPop(&optr, &ci);num = Caculate(number1, number2, ci ); //出栈计算OpndPush(&opnd, num);}else{printf(" 输入过多运算符!\n");system ("PAUSE");exit(0);}break;}//witch}//else}if(opnd.top -opnd.base >= 2){printf(" 俩个括号之间缺少运算符!\n ");system ("PAUSE");exit( 0 );}OpndPop(&opnd,&num); //直接把OPND的栈元素赋值给numprintf(" 运算结果为%.3f\n", num);}system ("PAUSE");}int InitOptrStack(OPTR * OP){OP->base = (char*)malloc((MAXSIZE+1)*sizeof(char));OP->top = OP->base;OP->stacksize = MAXSIZE;return OK;}int OptrPush(OPTR *OP, char ch){*(OP->top) = ch;OP->top++;return OK;}int OptrPop(OPTR *OP, char *ch){if(OP->base == OP->top)return ERROR;else{OP->top--;*ch = *(OP->top);return OK;}}int OptrEmpty(OPTR OP){if(OP.top == OP.base )return YES;elsereturn NO;}char GetOptrTop(OPTR OP){return *(OP.top -1);}int InitOpndStack(OPND * OP){if(!(OP->base = (float*)malloc((MAXSIZE+1)*sizeof(float)))) exit(OVERLOW);OP->top = OP->base;OP->stacksize = MAXSIZE;return OK;}int OpndPush(OPND *OP, float number) {*(OP->top) = number;OP->top++;return OK;}int OpndPop(OPND *OP, float* number) {if(OP->top == OP->base)return ERROR;else{OP->top--;*number = *(OP->top);return OK;}}int OpndEmpty(OPND OP){if(OP.top == OP.base )return YES;elsereturn NO;}int JudgeChar(char ch){if(ch>='0'&&ch<= '9')return NO;elsereturn YES;}float GetFloat(char* ch){int i;float num = 0;for( i = 0; *ch>= '0'&& *ch<= '9'; i++){ num = num*10 + *ch - '0';*ch = getchar();}return num;}char Precede(char a, char b){char ch;switch(a){case'+':case'-': if(b == '*' || b == '/' || b == '(')ch = '<';elsech = '>';break;case'*':case'/': if( b == '(')ch = '<';elsech = '>';break;case'(': if(b == ')')ch = '=';elseif(b == '#'){printf(" 缺少反括号\n");system ("PAUSE");exit(0);}elsech = '<';break;case')': if(b == '('){printf(" 两个括号之间没有符号相连!\n");system("PAUSE");exit(0);}ch = '>';break;case'#': if(b == '#')ch = '=';elseif(b == ')'){printf(" 没有左括号!\n ");system("PAUSE");exit(0);}elsech = '<';break;default: printf(" 输入运算符超出范围! \n ");system ("PAUSE");exit(0);break;}return ch;}float Caculate(float number1, float number2, char ci){float num;switch( ci){case'+': num = number1 + number2; break;case'-': num = number1 - number2; break;case'*': num = number1 * number2; break;case'/': num = number1 / number2; break;}return num;}3【算法思想】根据栈的原理,建立数字栈OPND和运算符号栈OPTR,对读入的字符进行判断,存入不同的栈内,每次读入一个字符就把该字符和运算符栈顶的优先级进行比较,然后选择相应的操作,这是这个程序的核心代码,如下:switch(Precede(GetOptrTop(optr),ch)){case '<':OptrPush(&optr,ch); //栈顶优先级低ch = getchar();break;case '=':OptrPop(&optr,&noMean); //左右括号,把左括号出栈ch = getchar ();break;case '>': //栈顶优先级高if(OpndPop(&opnd, &number2) && OpndPop(&opnd, &number1)){OptrPop(&optr, &ci);num = Caculate(number1, number2, ci ); //出栈计算OpndPush(&opnd, num);}else{printf(" 输入过多运算符!\n");system ("PAUSE");exit(0);}break;}//witch4【实现效果】完全可以实现题目的要求,除了下图的错误提示,本程序还可以提示的错误有:输入过多运算符,缺少反括号,两个括号之间缺少运算符相连,缺少左括号,输入的运算符超出范围等提示。

表达式求值课程设计

表达式求值课程设计

表达式求值课程设计一、课程目标知识目标:1. 学生能理解并掌握表达式求值的基本概念和方法。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

数据结构课程设计-表达式求值问题

数据结构课程设计-表达式求值问题

实验表达式求值问题1. 问题描述表达式是数据运算的基本形式。

人们的书写习惯是中缀式,如:11+22* (7-4 )/3. 中缀式的计算按运算符的优先级及括号优先的原则,相同级别从左到右进行计算。

表达式还有后缀表达式(如:11 22 7 4 - * 3 / + )和前缀表达式(+ 11 / * 22 - 7 4 3 )。

后缀表达式和前缀表达式中没有括号,给计算带来方便。

如后缀表达式计算时按运算符出现的先后进行计算。

本设计的主要任务是进行表达式形式的转换及不同形式的表达式计算。

2. 数据结构设计1)顺序栈类定义:首先应在类中定义成员函数,以此来完成顺序栈的相关操作,如下:class SqStackprivate:T *base; // 栈底指针int top; // 栈顶int stacksize; // 栈容量public:SqStack(int m); // 构建函数~SqStack(){delete [] base;top=0;stacksize=0;} // 析构函数void Push(T x); // 入栈T Pop(); // 出栈T GetTop(); // 获取栈顶元素int StackEmpty(); // 测栈空void ClearStack(); // 清空栈void StackTop(); // 返回栈顶指针void StackTranverse(); // 显示栈中元素};2)顺序栈类实现:对顺序栈进行初始化,初始化的首要操作就是创建一个空顺序栈。

Step1 :申请一组连续的内存空间为顺序栈使用:base=new T[m];i f(base==NULL)cout<<" 栈创建失败,退出!"<<endl; exit(1);}{Step2 :给栈顶、栈容量赋相应的值:stacksize=m;t op=-1;(2)顺序栈入栈:入栈需要在栈顶插入一个新元素并相应的调整栈顶。

表达式求值课程设计c++

表达式求值课程设计c++

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

C语言_算数表达式求值_课程设计报告

C语言_算数表达式求值_课程设计报告

目录一.概述 (2)二.总体方案设计 (2)三.详细设计 (4)四.程序的调试与运行结果说明 (6)五.课程设计总结 (6)错误!未定义书签。

参考文献附录 (8)概述一、课程设计的目的与要求本课程设计是为了配合《数据结构》课程的开设,通过设计一个完整的程序,使学生掌握数据结构的应用,算法的编写,类C 语言的算法转换成C 程序并用Turbo C2.0 或Visual C++6.0 上机调试的基本方法。

要求如下:1. 要充分认识课程设计对自己的重要性,认真做好课程设计前的各项准备工作。

2. 既要虚心接受老师的指导,又要充分发挥主观能动性.结合课题, 独立思考,努力钻研,勤于实践,勇于创新。

3. 独立按时完成规定的工作任务,不得弄虚作假,不准抄袭他人内容,否则成绩以不及格计。

4. 课程设计期间,无故缺席按旷课处理;缺席时间达四分之一以上者,其成绩按不及格处理。

5. 在设计过程中,要严格要求自己,树立严肃,严密,严谨的科学态度, 必须按时,按质,按量完成课程设计。

6. 小组成员之间,分工明确,但要保持联系畅通,密切合作,培养良好的互相帮助和团队协作精神。

二、需求分析本课程设计的课题为表达式求值,要求:1. 用户将表达式原样输入(在表达式结尾加上#),能得出结果(为减小难度,运算结果的10 进制形式的值,不超过longdouble 的存储范围);2. 输入的数可以为小数(为减小难度,小数的整数与小数部分均不超过10 位),负数(如果负数前有运算符,则应将负数括起来),以及2进制,8进制,10 进制,16进制的数(为减小难度,数出的结果都以10 进制形式表示);3. 运算符号包括()、+、—、* 、/;括号可以多重;二总体方案设计1. 使用双链表的数据结构表示数据的存储,将用户输入的表达式以字符形式存入双链表中。

2. 对以负数开头、以括号开头、左括号后紧跟负数的特殊情况作处理。

3. 将数与运算符分开;4. ........................................................................................ 依次找到表达式最内层括号,次内层括号............... 每次找到括号内的表达式,便将其进行只有加减乘除运算的计算。

表达式求值的课程设计

表达式求值的课程设计

表达式求值的课程设计一、课程目标知识目标: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,用于存放操作符。

数据结构课设 表达式求值

数据结构课设 表达式求值

《计算表达式》课程设计报告标题:计算表达式单位:报告人:指导教师:编程环境:VC6时间:2011年12月20日一、设计要求对于输入的一个中缀表达式,判断表达式是否合法。

如果合法,把中缀表达式转换成一棵二叉树,然后通过后根遍历计算表达式的值,输出运算结果。

合法表达式不能为空,可以出现在表达式中的字符有:*运算符“+”、“-”、“*”、“/”;*左右括号“(”、“)”;*整数(可以是多位的);*空格符和制表符。

例如:表达式为“20+(3*(4+46)-6)/2-134”将得到结果-42。

数据结构采用二叉树的链接表示。

二、题目分析由设计要求可以确定程序的几大模块,读入源程序(1)读入中缀表达式(2)从中缀表达式ex(长度为n)创建二叉树(3)后根遍历计算表达式的值(4)输出运算结果进一步确定几个子程序及其相互之间的调用关系为:三.流程图四.全局变量与子程序功能说明(1)int extoBinTree(PBinTree pbtree,const char *ex,int n)从中缀表达式ex(长度为n)创建二叉树。

若是一个合法的表达式,则返回TRUE,且算法结束时*pbtree存放二叉树的根节点的地址;否则返回FALSE(2)int cal(BinTree btree,int*presult)计算二叉树btree所代表的表达式的值。

若是一个合法的表达式,则返回TRUE,且算法结束时*presult中存放计算结果;否则,返回FALSE.(3)void delete_BTree(PBinTree ptree){BinTree temp=(*ptree);if(temp==NULL) return;delete_BTree(&(temp->llink));delete_BTree(&(temp->rlink));free(temp);}作用为,当输入的程序有误时,或者一段表达式已经运算结束时清除储存空间,为下一段表达式的计算作准备。

数据结构(C语言版)课程设计报告表达式求值说明书

数据结构(C语言版)课程设计报告表达式求值说明书

数据结构(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磅。

一级标题靠左,加粗。

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

数据结构课程设计算术表达式求值

数据结构课程设计算术表达式求值

计算机科学系《数据结构课程设计》报告课题名称:算术表达式求值目录1.问题描述-----------------------------------------------------------32.基本要求-----------------------------------------------------------33.工具/准备工作----------------------------------------------------34.分析与实现--------------------------------------------------------45. 课程设计体会与感悟------------------------------------------161.问题描述从键盘上输入中缀算术表达式,包括括号,计算出表达式的值。

2.基本要求(1)程序能对所输入的表达式做简单的判断,如表达式有错,能给适当提示。

(2)能处理单目运算符:+,-。

3.工具/准备工作在开始项目之前,应回顾复习相关内容。

需要一台计算机装有visual C++。

4.分析与实现对于中缀表达式,一般运算规则如下:(1)先乘方,再乘除,最后加减;(2)同级运算从左算到右;(3)先括号内再括号外;(4)用到的头文件”utility.h”,”lk_stack.h”,”node.h”,”calculator.h”.根据实践经验,可以对运算符设置统一的优先级,从而方便比较。

表中给出了包括加、上面讨论的的+、—为双目运算符,如为单目运算符,编程实现时,可在前面加上0而转化为双目运算符。

如在+、—的前一个字符(如当前字符不是运算符时,规定用0表示)为‘=’或‘(’,则为单目运算符。

具体实现算法时,可设置两个工作栈,一个为操作栈,一个为操作符栈optr,另外一个为操作数栈opnd,算法基本思路如下:(1)将optr栈和opnd栈清空,在optr栈中加入一个‘=‘。

数据结构课程设计表达式求值问题

数据结构课程设计表达式求值问题

课程设计(论文)题目名称表达式求值问题课程名称数据结构课程设计学生姓名XXX学号xxxxxxxxx系、专业信息工程系、信息工程类指导教师xxxxxx2020年1 月3 日目录1 问题描述 (2)2 需求分析 (2)3 概要设计 (2)3.1抽象数据类型概念 (2)3.2模块划分 (3)4 详细设计 (4)4.1数据类型的概念 (4)4.2要紧模块的算法描述 (4)5.1程序运行结果: (6)5.2程序调试与体会 (7)运用栈的大体操作顺利的解决表达式求值及转换问题,要紧利用栈的先进后出结构,执行出栈进栈操作并在出栈时进行配对并输出配对情形,而整个进程不需要不需要移动元素使程序在空间复杂度上降到最小,采纳指针的移动大大加速了程序的执行效率。

而且对输入进行了改良,以避免用户随意输入时显现的各类意想不到的错误。

系统整体上比较完美,不管是输入、输出,仍是整个系统的界面,都超级美观、简练、大方 (7)6 课程设计总结 (7)参考文献 (8)附录(源程序清单) (9)1 问题描述编写一个表达式求值程序,使输入一个四那么运算表达式后,能够返回正确的结果。

该表达式由数字0~九、+、-、*、/、括号组成,且表达式必需正确无误。

程序的编写可用到栈或队列的大体算法,求出该表达式的值,并分析算法的时刻复杂度和运算的结果。

2 需求分析(1)为实现算符优先算法,能够利用两个工作栈。

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

算法的大体思想是:①第一置操作数栈为空栈,表达式起始符“#”为运算符栈的栈底元素;②依次读入表达式中每一个字符,假设是操作数那么OPND栈,假设是运算符,那么和OPTR栈的栈顶运算符比较优先权后做相应操作,直至整个表达式求值完毕(即OPTR栈的栈顶元素和当前读入的字符均为"#")。

(2)该程序实现表达式的求值问题:从键盘读入一个合法的算术表达式,利用算符优先关系,实现对算术四那么混合运算的求值,输出正确的结果。

表达式计算课程设计

表达式计算课程设计

表达式计算课程设计一、课程目标知识目标:1. 学生能理解表达式计算的基本概念,掌握算术表达式、布尔表达式的构成及运算规则。

2. 学生能运用所学知识,正确编写简单的表达式,解决实际问题。

3. 学生了解表达式计算在编程和生活中的应用,理解其在信息技术领域的重要性。

技能目标:1. 学生能够运用所学知识,熟练使用计算器或编程工具进行表达式的输入和计算。

2. 学生能够分析问题,将实际问题转化为表达式计算问题,并独立解决。

3. 学生能够通过小组合作,共同探讨表达式计算的优化方法,提高计算效率。

情感态度价值观目标:1. 学生对表达式计算产生兴趣,培养主动学习和探究的精神。

2. 学生在解决问题的过程中,培养耐心、细致的良好学习习惯。

3. 学生通过合作学习,学会倾听他人意见,提高团队协作能力。

4. 学生认识到表达式计算在现实生活中的广泛应用,增强学以致用的意识。

课程性质:本课程为信息技术课程,旨在培养学生的计算思维和实际操作能力。

学生特点:五年级学生具备一定的逻辑思维能力,对新鲜事物充满好奇心,喜欢动手实践。

教学要求:教师应注重启发式教学,引导学生主动参与,关注学生的个体差异,提高学生的实践能力。

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

二、教学内容本章节教学内容主要包括以下三个方面:1. 表达式计算的基本概念- 算术表达式的构成及运算规则- 布尔表达式的构成及运算规则- 表达式计算在实际问题中的应用2. 表达式计算的方法与技巧- 使用计算器进行表达式计算- 编程工具中表达式计算的实现方法- 表达式计算的优化技巧3. 表达式计算的应用实践- 将实际问题转化为表达式计算问题- 设计并实现简单的表达式计算程序- 合作探讨表达式计算的优化方法教学大纲安排如下:1. 引言与算术表达式(1课时)- 介绍表达式计算的基本概念,引导学生了解算术表达式的构成及运算规则。

2. 布尔表达式与表达式计算应用(1课时)- 深入学习布尔表达式的构成及运算规则,探讨表达式计算在实际问题中的应用。

C语言_算数表达式求值_课程设计报告

C语言_算数表达式求值_课程设计报告
达式的输入,得出了正确结果,但不排除还有某些漏洞使得一些特殊情况的表达式不能得出正确结果,还有待进一步的测试。
特点:本程序能进行小数、以及2进制、8进制、16进制的运算。
不足:结果都以10进制形式表示,用户不能改变;结果的10进制形式不能超
出longdouble型数据能存储的数的范围;
进一步的设想:将数分段存储,内存动态分配,使其能进行天文数字运算;录入其他的运算符例如指数运算,开方运算,取余运算,解一元一次方程,解二元一次方程组。
三 详细设计
我任务是整个程序的算法设计, 以及部分子函数的编写, 经过其他组员编写的子函数的处理, 将表达式变为一个普通的表达式, 其中数与运算符已经分开,将这个表达式的头指针传递到我所编写函数
中,运算思想为:找到最内层的一对括号, 计算括号间的表达式的值,得到值之后,用这个值替换掉原始位置上的一对括号, 以及其中的表达式。例如(((6.5-2*2.25)*2-6)/2+1.5)+3#,第一次替换后为((2*2-6)/2+1.5)+3#,第二次替换后为(-2/2+1.5)+3#,第三次替换后为0.5+3#,当没有括号时调用四则运算函数直接计算。
Node *node,*head;
Node_ys_char *node_char;
switch(m)
{
case 2:
JiWei=2;
max=50;
break;
case 8:
JiWei=8;
max=56;
break;
case 10:
JiWei=10;
max=97;
break;
case 16:
JiWei=16;
p->c='+';
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

数据结构课程设计设计说明书算术表达式求值问题学生姓名白子健学号1318014057 班级计本1302 成绩指导教师李军计算机科学与技术系2015年9月10日数据结构课程设计评阅书课程设计任务书2015—2016学年第一学期专业:计算机科学与技术学号:1318014057 姓名:白子健课程设计名称:课程设计Ⅰ---数据结构课程设计设计题目:表达式求值算法的实现完成期限:自2015 年9 月 1 日至2015 年9 月12 日共 2 周设计内容及要求:算术表达式求值是程序设计语言编译中的一个基本问题,通过栈实现表达式运算优先级的匹配和运算。

用C/C++语言编程实现任意算术表达式的求值,设计内容要求如下:(1)表达式共有三种基本表示方法:前缀法、中缀法、后缀法。

从表达式的这三种基本方法中任选一种方法进行编程求值。

(2)分析所选的表示方法,根据选定的表示方法确定对应的存储结构和相关算法。

(3)算法要能正确处理算术运算的优先级规则,即: 先括号内,后括号外的规则;运算先乘除,后加减;同级运算从左到右。

如下表达式:50+(6*3+2)要求:(1)用C/C++语言编写一个程序将这组学生成绩输入到计算机中,数据运算的存储逻辑结构为栈。

(2)程序要能正确处理表达式的优先级、输出正确运算结果。

最终设计成果形式为:1、设计好的软件一套;2、撰写一份课程设计说明书一份,打印并装订成册。

指导教师(签字):教研室主任(签字):批准日期:年月日目录1 课题描述 (1)2 设计思路 (2)3 算法设计 (3)4 程序代码 (5)5 测试及分析 (12)6 总结 (13)参考文献 (13)1 课题描述表达式求值是程序设计语言编译中的一个最基本问题。

表达式求值在计算机中的实现是栈结构在计算机中的一个典型应用。

这里使用“算符优先算法”实现表达式求值。

要把一个表达式翻译成正确求值的一个机器指令序列,或者直接对表达式求值,首先要能够正确解释表达式。

例如对表达式求值:50+(6*3+2)首先要了解算术四则运算的规则。

即:先算括号内,后算括号外;先乘除后加减;同级运算顺序从左到右;所以,这个表达式的运算顺序为:50+(6*3+2)=50+(18+2)=50+20=70算符优先算法就是根据这个运算优先关系来编译或者解释执行的。

2 设计思路2.1表达式的输入:表达式从键盘输入,存入字符串数组中。

2.2运算的实现:任何一个表达式都是由操作数(operand)、运算符(operator)和界限符(delimiter)组成的。

可以把运算符和界限符统称为算符,根据算术运算规则,在运算的每一步中,任意两个相继出现的算符opt1和opt2之间的优先关系至多是下面三种关系之一:opt1<opt2,即opt1的优先级低于opt2;opt1=opt2,即opt1的优先级等于opt2;opt1>opt2,即opt1的优先级高于opt2。

表1定义了算符间的优先关系:输入的表达式(包含运算符和操作数)以字符串的形式输入,故需要一个字符串数组存储键盘的输入。

在对输入的表达式求值前,应先检查输入的合法性。

只有正确的输入才能输出正确的计算结果。

算符优先算法运算需要两个栈:操作数栈(OPND)和运算符栈(OPTR)。

栈可以采用数组实现,并定义栈的相关操作:初始化、压栈、出栈、判断栈满、判断栈空等相关操作。

输入的字符串解析分离出操作数和运算符,分别进入操作数栈和运算符栈。

运算始终在栈顶实现,最终操作数栈只剩一个元素,即运算结果。

3算法设计使用两个工作栈:一个称作OPTR,用以寄存运算符;另一个称作OPTD,用以寄存操作数或运算结果。

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

算法如下:OperandType EvaluateExpression(){//算术表达式求值的算符优先算法。

OPTR和OPND分别为运算符栈和运算数栈//OP为运算符集合{+、-、*、/、(、)、#、.}InitStack(OPTR);Push(OPTR, ‘#’);InitStack(OPND);c = getchar();while (c!=’#’ || GetTop(OPTR)!=’#’){if (!IsOpt(c)){Push(OPND, c); c = getchar();} //不是运算符则进栈;else{switch (Precede(GetTop(OPTR), c)){case ‘<’://栈顶元素优先级低Push(OPTR, c);c = getchar();break;case ‘=’://脱括号并接收下一字符Pop(OPTR, x);c = getchar();break;case ‘>’://退栈并将运算结果入栈Pop(OPTR, theta);Pop(OPND, b);Pop(OPND, a);Push(OPND, Operate(a, theta, b));break;}//switch}//whileReturn GetTop(OPND);}//EvaluateExpression算法中还调用了两个函数。

其中Precede是判定运算符栈的栈顶运算符opt1与读入的运算符opt2之间优先关系的函数;Operate为进行二元运算a opt b的函数,如果是编译表达式,则产生这个运算的一组相应指令并返回存放结果的中间变量名;如果是解释执行表达式,则直接进行该运算,并返回运算的结果。

程序流程图如下:4程序代码#if 0/*2015年9月8日09:10:14表达式求值算法——算符优先算法的实现*/#endif#define Debuging 0 //当值为一时,开启调试#include <stdio.h>#include <stdlib.h>#include <string.h>#define OVERFLOW -2#define ERROR 0#define INFEASIBLE -1#define OK 1#define TRUE 1#define FALSE 0#define OPERAND double#define OPERATOR char#define STACK_INIT_SIZE 100#define STACKINCREMENT 10#define MAX_QUEUE_SIZE 100#define OPERATORNUM 8 //操作符的数量typedef struct{/*定义操作数栈*/OPERAND * base;OPERAND * top;int iStackSize;}OPNDStack, *pOPNDStack;typedef struct{/*定义运算符栈*/OPERATOR * base;OPERATOR * top;int iStackSize;}OPTRStack, *pOPTRStack;char cOpt[] = {'+', '-', '*', '/', '(', ')', '#', '.'};char cPriority[7][7] = {{'>', '>', '<', '<', '<', '>', '>'},{'>', '>', '<', '<', '<', '>', '>'},{'>', '>', '>', '>', '<', '>', '>'},{'>', '>', '>', '>', '<', '>', '>'},{'<', '<', '<', '<', '<', '=', NULL},{'>', '>', '>', '>', NULL, '>', '>'},{'<', '<', '<', '<', '<', NULL, '='}};int InitOPNDStack(pOPNDStack S);OPERAND GetOPNDTop(pOPNDStack S);int PushOPND(pOPNDStack, OPERAND e);int PopOPND(pOPNDStack S, OPERAND * e);int InitOPTRStack(pOPTRStack S);OPERATOR GetOPTRTop(pOPTRStack S);int PushOPTR(pOPTRStack S, OPERATOR e);int PopOPTR(pOPTRStack S, OPERA TOR * e);OPERAND Operate(OPERAND fOperandA, OPERATOR cOperator, OPERAND fOperandB); OPERAND EvaluateExpression(char * Expression);int WhichOptNum(char opt);int IsOpt(char opt);int CheckExpression(char *Expression);int main(void){//表达式求值——算符优先算法OPERAND e = 0.0;char Expression[50] = " ";system("color f0");while(OK){fflush(stdin);printf("输入表达式:");gets(Expression);strcat(Expression, "#");//printf("%s", cPriority);if (CheckExpression(Expression)){e = EvaluateExpression(Expression);printf("Answer = %f\n", e);}else{printf("输入中缀表达式有误!\n");continue;}}return 0;}//mainint InitOPNDStack(pOPNDStack S){//构造一个空栈,栈内数据类型为OPND(浮点数据)S->base = (OPERAND *)malloc(STACK_INIT_SIZE * sizeof(OPERAND));if (!S->base)exit(OVERFLOW); //这么写错误处理显然还不成熟S->top = S->base;S->iStackSize = STACK_INIT_SIZE;return OK;}//InitOPNDStackOPERAND GetOPNDTop(pOPNDStack S){//读取栈顶元素,不删除栈顶元素if (S->top == S->base)exit(OVERFLOW);//栈空return *(S->top - 1);}//GetOPNDTopint PushOPND(pOPNDStack S, OPERAND e){//将新的OPND元素入栈,栈满则增加空间if (S->top - S->base >= S->iStackSize){S->base=(OPERAND*)realloc(S->base, \(S->iStackSize+STACKINCREMENT)*sizeof(OPERAND));if (!S->base)exit(OVERFLOW); //空间不够了S->top = S->base + S->iStackSize;S->iStackSize += STACKINCREMENT;#if Debugingprintf("增加OPND空间辣!\n");system("pause");#endif}//if*(S->top++) = e;return OK;}//PushOPNDint PopOPND(pOPNDStack S, OPERAND * e){//若栈不空,删除S栈顶元素,并用e返回其值if (S->top == S->base)return ERROR;*e = *(--S->top);return OK;}//PopOPNDint InitOPTRStack(pOPTRStack S){//构造一个空栈,栈内数据类型为OPTRS->base = (OPERATOR *)malloc(STACK_INIT_SIZE * sizeof(OPERATOR));if (!S->base)exit(OVERFLOW); //这么写错误处理显然还不成熟S->top = S->base;S->iStackSize = STACK_INIT_SIZE;return OK;}//InitOPTRStackOPERATOR GetOPTRTop(pOPTRStack S){//读取栈顶元素,不删除栈顶元素if (S->top == S->base)exit(OVERFLOW); //栈空return *(S->top - 1);}//GetOPTRTop//哎。

相关文档
最新文档