《数据结构 课程设计》表达式求值 实验报告

合集下载

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

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

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

一.需求分析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、设计要求:给定一个算术表达式,通过程序求出最后的结果 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>最初设计的运行界面过于单调,不够友好,改进时加入一些*调整调整结果如下:五、课程设计总结本学期是我第一次接触课程设计,发现了很多学习上的问题,也有很多收获。

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

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

数据结构表达式求值实验报告一、设计人员相关信息1. 设计者姓名、学号和班号:12地信李晓婧 120122429832. 设计日期:2014.3. 上机环境:VC++6.0二、程序设计相关信息1(实验题目:用户输入一个包含+、-、*、/、正整数和圆括号的合法算术表达式,计算该表达式的运算结果。

2(实验项目组成:先将算术表达式转换成后缀表达式,然后对改后缀表达式求值。

3(实验项目的程序结构(程序中的函数调用关系图):mainLeftpririghpriinopprecedetranscompvalue4(实验项目包含的各个文件中的函数的功能描述: , rightpri(char op) //求右运算符的优先级, rightpri(char op) //求右运算符的优先级, inop(char ch) //判断CH是否为运算符 , precede(char op1,char op2) //OP1和OP2运算符优先级的比较 , compvalue(char *postexp) //计算后缀表达式5(算法描述或流程图:#include<stdio.h>#include<stdlib.h>#define maxop 50#define maxsize 50struct{ char ch;int pri;}lpri[]={{'=',0},{'(',1},{'*',5},{'/',5},{'+',3},{'-',3},{')',6}}, rpri[]={{'=',0},{'(',6},{'*',4},{'/',4},{'+',2},{'-',2},{')',1}};int leftpri(char op) //求左运算符的优先级{ int i;for(i=0;i<maxop;i++)if(lpri[i].ch==op)return lpri[i].pri;}int rightpri(char op) //求右运算符的优先级{ int i;for(i=0;i<maxop;i++)if(rpri[i].ch==op)return rpri[i].pri;}int inop(char ch) //判断CH是否为运算符{ if(ch=='('||ch==')'||ch=='+'||ch=='-'||ch=='*'||ch=='/') return true;elsereturn false;}int precede(char op1,char op2) //OP1和OP2运算符优先级的比较{ if(leftpri(op1)==rightpri(op2))return 0;else if (leftpri(op1)<rightpri(op2))return -1;elsereturn 1;}void trans(char *exp,char postexp[]){ struct{char data[maxsize]; //存放运算符int top; //栈指针}op; //定义一个运算符int i=0;op.top=-1;op.top++; //将=进栈op.data[op.top]='='; while(*exp!='\0') //EXP表达式没扫描完时循环{ if(!inop(* exp)) {while(* exp>='0'&& * exp<='9') //判断为数字{ postexp[i++]= * exp;exp++;}postexp[i++]='#'; //用#表示一个数值串结束 }elseswitch(precede(op.data[op.top], * exp)){case -1: //栈顶运算符的优先级低op.top++;op.data[op.top]= * exp;exp++;break;case 0:op.top--;exp++;break;case 1: //退栈并输出到POSTEXP中postexp[i++]=op.data[op.top];op.top--;break;}}while (op.data[op.top]!='='){ postexp[i++]=op.data[op.top];op.top--;}postexp[i]='\0';}float compvalue(char *postexp) //计算后缀表达式 { struct {float data[maxsize]; //存放数值int top;}st; //定义一个运算数栈 float d,a,b,c;st.top=-1;while(* postexp!='\0') //POSTEXP字符串未扫描时循环{ switch(*postexp) {case'+': //判定+a=st.data[st.top];st.top--; //退栈取数值Ab=st.data[st.top];st.top--; //退栈取数值,c=a+b; //计算Cst.top++;st.data[st.top]=c;break;case'-': //判断-a=st.data[st.top];st.top--; //退栈取Ab=st.data[st.top];st.top--; //退栈取Bc=b-a;st.top++;st.data[st.top]=c; //将计算结果进栈break;case'*':a=st.data[st.top];st.top--;b=st.data[st.top];st.top--;c=a*b;st.top++;st.data[st.top]=c;break;case'/':a=st.data[st.top];st.top--;b=st.data[st.top];st.top--;if(a!=0){ c=b/a;st.top++;st.data[st.top]=c;}else{printf("\n\t除零错误!\n");exit(0); //异常退出}break;default: //处理数字字符{ d=0;while(* postexp>='0'&& *postexp<='9') //判断为数字字符postexp++;}st.top++;st.data[st.top]=d;break;}postexp++; //继续处理其他字符)}return(st.data[st.top]); }void main(){ char exp[]="(50-20)/(4+2)";char postexp[maxsize];trans(exp,postexp);printf("中缀表达式:%s\n",exp);printf("后缀表达式:%s\n",postexp);printf("表达式的值:%g\n",compvalue(postexp)); }6(实验数据和实验结果:7(出现的问题及解决方法: 问题1:解决方法:修改宏定义,将maxop的值改小。

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

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

软件学院课程设计报告书课程名称数据结构设计题目算术表达式求值演示程序专业班级嵌入式软件10-1班学号 1020030104姓名董俊指导教师冯永安2012年1月目录1.设计时间 (2)2.设计目的 (2)3.设计任务 (2)4.设计内容 (2)4.1需求分析 (2)4.2总体设计 (2)4.2.1抽象数据类型的定义 (2)4.2.2函数模块说明 (3)4.2.3主函数流程图 (4)4.2.4函数模块调用关系 (5)4.2.5运算符间的优先关系 (5)4.3详细设计 (6)4.3.1数据类型的定义 (6)4.3.2函数调用关系 (8)4.3.3主要模块的算法描述 (8)4.4测试与分析 (10)4.4.1测试 (10)4.4.2分析 (11)4.5附录 (11)5.总结与心得体会 (16)参考文献 (17)成绩评定 (17)开始Char c; SqStack OPTR,OPND;c=getchar()C!=’#’||GetTop(OPTR)!=’#’c>=’0’&&c<=’9’Precede(GetTop(OPTR),c)Push(OPTR,c)C=getchar()Pop(OPTR,c)Pop(OPTR,theta);Pop(OPND,b);Pop(OPND,a);Push(OPND,Operate(a,tehta,b));Return GetTop(OPND)结束主程序模块栈的建立及初始化模块判断输入是否结束模块判断字符类型模块输入结束输出结果运算数进栈模块运算符优先级比较模块运算符进栈模块运算符运算数出栈模块运算模块main()SqStackC=getchar()InitStackc Push_N(&OPND,i)switch(Predece(GetTop_T(&OPTR),c))theta=Pop_T(&OPTR);b=Pop_N(&OPND);a=Pop_N(&OPND);Push_N(&OPND,Operate(a,theta,b))Push_T(&OPTR,c)GetTop_N(&OPND)。

数据结构表达式求值完整篇(含实验报告)

数据结构表达式求值完整篇(含实验报告)
voidOPND_Pop(Sqstack_OPND
&s,SElemType_OPND&e); //出栈
/*
#i nclude "common .h"
#include "Sqstack.h"
#in clude "other.h"
//
void OPTR_I ni tStack(Sqstack_OPTR &s)
3前面的都听简单的,就是 小数编写这块想了很久,
定义了low做判定符号的标志。如果在运算符后输入负号则low=-1(将p入栈时入栈
的是p*low),继续输入ch
总结:
我觉得写的好的地方在于定义了flag,low分别作为小数入栈和负号与减号区别的条
件。第一次写这么长的代码,还有就是将输入的字符再转到小数这段代码可以留着很有 用。开始考虑的大整数想麻烦了,直接用double难度降低了很多
//取操作数的栈顶元素
voidOPTR_Push(Sqstack_OPTR
&s,SElemType_OPTR e);//入栈
voidOPND_Push(Sqstack_OPND
&s,SElemType_OPND e); //入栈
voidOPTR_Pop(Sqstack_OPTR
&s,SEIemType_OPTR&e); //出栈
//栈基本操作的函数声明
void OPTR_lnitStack(Sqstack_OPTR &s);
//运算符栈初始化
void OPBiblioteka D_InitStack(Sqstack_OPND &s);
//操作数栈初始化

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

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

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【实现效果】完全可以实现题目的要求,除了下图的错误提示,本程序还可以提示的错误有:输入过多运算符,缺少反括号,两个括号之间缺少运算符相连,缺少左括号,输入的运算符超出范围等提示。

数据结构 四则运算表达式求值 实验四报告

数据结构 四则运算表达式求值 实验四报告

为后缀表达式。
(3) 计算模块:计算后缀表达式的值。
(4) 输出模块:输出后缀表达式及其计算结果。
三、详细设计
物理数据类型
因为表达式由用户输入,存储操作符和操作数的栈长度不能确定,所以使用链式堆栈存
储这些变量。
堆栈基本操作如下:
bool push(const Elem& item) //压栈
{
top=new link<Elem>(item,top);
表达式。
运算时,运算符栈顶弹栈,然后获取操作数栈顶和次栈顶的值进行运算,把运算结果创
建一个叶子结点保存,把结点压回操作数栈中。如果操作数栈或运算符栈不为空时,继续进
行运算操作。最后操作数栈中的值,就是运算结果。
程序的流程
(1) 输入模块:输入把原始的中缀表达式的操作数和操作字符存储为一个字符串。 (2) 处理模块:把字符串逐个分解,调整各项字符的顺序,分解的中缀表达式转换
EvalExpr(ch[i],S); //弹栈,运算部分
i++;
}
}
if(S.length()==1)
S.pop(result);
}
(2)、 转换实数
int EvalValue(char* ch,Stack<double> &S)
{
int i=0;
double result=0;
char a;
a=ch[i];
}
bool topValue(Elem& it) const //获取栈顶的值
{
if(size==0) return false;
it=top->elem;
return true;

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

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

程设计报告课程名称数据结构课题名称中缀算术表达式求值专业通信工程班级通信0902学号姓名指导教师2011 年07 月01 日湖南工程学院课程设计任务书课程名称数据结构课题中缀算术表达式求值专业班级通信工程0902学生姓名学号指导老师审批任务书下达日期2011 年06 月27 日任务完成日期2011 年07 月01 日设计要求:1. 课程设计报告规范1)需求分析a.程序的功能。

b.输入输出的要求。

(2)概要设计a.程序由哪些模块组成以及模块之间的层次结构、各模块的调用关系;每个模块的功能。

b.课题涉及的数据结构和数据库结构;即要存储什么数据,这些数据是什么样的结构,它们之间有什么关系等。

(3)详细设计a.采用 C 语言定义相关的数据类型。

b.写出各模块的类C 码算法。

c.画出各函数的调用关系图、主要函数的流程图。

(4)调试分析以及设计体会a.测试数据:准备典型的测试数据和测试方案,包括正确的输入及输出结果和含有错误的输入及输出结果。

b.程序调试中遇到的问题以及解决问题的方法。

c.课程设计过程经验教训、心得体会。

(5)使用说明用户使用手册:说明如何使用你编写的程序,详细列出每一步的操作步骤。

(6)书写格式a.设计报告要求用A4 纸打印成册:b.一级标题用 3 号黑体,二级标题用四号宋体加粗,正文用小四号宋体;行距为22。

(7)附录源程序清单(带注释)2. 考核方式指导老师负责验收程序的运行结果,并结合学生的工作态度、实际动手能力、创新精神和设计报告等进行综合考评,并按优秀、良好、中等、及格和不及格五个等级给出每位同学的课程设计成绩。

具体考核标准包含以下几个部分:(1)平时出勤(占10%)( 2)系统需求分析、功能设计、数据结构设计及程序总体结构合理与否(占10%)( 3)程序能否完整、准确地运行,个人能否独立、熟练地调试程序(占40%)(4)设计报告(占30%)注意:不得抄袭他人的报告(或给他人抄袭),一旦发现,成绩为零分。

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

实验课程名称专业班级学生姓名学号指导教师20 至 20 学年第学期第至周算术表达式求值演示一、概述数据结构课程设计,要求学生在数据结构的逻辑特性和物理表示、数据结构的选择和应用、算法的设计及其实现等方面,加深对课程基本内容的理解。

同时,在程序设计方法以及上机操作等基本技能和科学作风方面受到比较系统和严格的训练。

在这次的课程设计中我选择的题目是算术表达式求值演示。

表达式计算是实现程序设计语言的基本问题之一,也是栈的应用的一个典型例子。

设计一个程序,演示用算符优先法对算术表达式求值的过程。

深入了解栈和队列的特性,以便在解决实际问题中灵活运用它们,同时加深对这种结构的理解和认识。

二、系统分析1.以字符列的形式从终端输入语法正确的、不含变量的整数表达式。

利用已知的算符优先关系,实现对算术四则混合运算表达式的求值,并仿照教科书的例子在求值中运算符栈、运算数栈、输入字符和主要操作的变化过程。

2.一般来说,计算机解决一个具体问题时,需要经过几个步骤:首先要从具体问题抽象出一个适当的数学模型,然后设计一个解决此数学模型的算法,最后编出程序,进行测试,调试直至得到想要的答案。

对于算术表达式这个程序,主要利用栈,把运算的先后步骤进行分析并实现简单的运算!为实现算符优先算法,可以使用两个栈,一个用以寄存运算符,另一个用以寄存操作数和运算结果。

3.演示程序是以用户于计算机的对话方式执行,这需要一个模块来完成使用者与计算机语言的转化。

4.程序执行时的命令:本程序为了使用具体,采用菜单式的方式来完成程序的演示,几乎不用输入什么特殊的命令,只需按提示输入表达式即可。

(要注意输入时格式,否者可能会引起一些错误)5. 测试数据。

三、概要设计一个算术表达式中除了括号、界限符外,还包括运算数据和运算符。

由于运算符有优先级别之差,所以一个表达式的运算不可能总是从左至右的循序执行。

每次操作的数据或运算符都是最近输入的,这与栈的特性相吻合,故本课程设计借助栈来实现按运算符的优先级完成表达式的求值计算。

算法设计程序包含三个模块(1) 主程序模块,其中主函数为void main{输入表达式;根据要求进行转换并求值;输出结果;}(2) 表达式求值模块——实现具体求值。

(3) 表达式转换模块——实现转换。

各个函数之间的调用关系栈的抽象数据类型定义ADT SqStack{数据对象:D={a i| a i∈ElemSet,i=1,2,3……,n,n≥0}数据关系:R1={<a i-1,a i>| a i-1,a i∈D,i=1,2,3,……,n}约定其中a i端为栈底,a n端为栈顶。

操作集合:(1)void InitStack1(SqStack1 &S1);//声明栈建立函数(2)void InitStack2(SqStack2 &S2);//声明栈建立函数(3)void evaluate(SqStack1 &S1,SqStack2 &S2);//确定如何入栈函数(4)void Push1(SqStack1 &S1,char e);//声明入栈函数(5)void Push2(SqStack2 &S2,float e);//声明入压栈函数(6)char GetTop1(SqStack1 &S1);//声明取栈顶元素函数(7)float GetTop2(SqStack2 &S2);//声明取栈顶元素函数(8)char Pop1(SqStack1 &S1);//声明出栈函数(9)float Pop2(SqStack2 &S2);//声明出栈函数(10)char Compare(char m,char n);//声明比较函数(11)float Operate(float a,char rheta,float b);//声明运算函数(12)void DispStack1(SqStack1 &S1);//从栈底到栈顶依次输出各元素(13)void DispStack2(SqStack2 &S2);//从栈底到栈顶依次输出各元素}ADT SqStack结构分析:栈中的数据节点是通过数组来存储的。

因为在C语言中数组是用下标从零开始的,因此我们在调用他们的数据是要特别注意。

指针变量的值要么为空(NULL),不指向任何结点;要么其值为非空,即它的值是一个结点的存储地址。

注意,当P为空值时,则它不指向任何结点,此时不能通过P来访问结点,否则会引起程序错误。

如果输入的数字不符合题目要求,则会产生错误结果。

算法的时空分析:时间和空间性能分析:时间上,对于含n个字符的表达式,无论是对其进行合法性检测还是对其进行入栈出栈操作n次,因此其时间复杂度为O(n)。

空间上,由于是用数组来存储输入的表达式,用栈来存储运算中的数据和运算符,而栈的本质也用到的数组,数组在定义时必须确定其大小。

在不知表达式长度的情况下确定数组的长度确非易事,此时极易造成空间的浪费,因此空间性能不是很好。

四、详细设计源程序#include<iostream>using namespace std;#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef struct //运算符栈{char *base;char *top;int stacksize;}SqStack1;typedef struct //运算数栈{float *base;float *top;int stacksize;}SqStack2;void InitStack1(SqStack1 &S1);//声明栈建立函数void InitStack2(SqStack2 &S2);//声明栈建立函数void evaluate(SqStack1 &S1,SqStack2 &S2);//确定如何入栈函数void Push1(SqStack1 &S1,char e);//声明入栈函数void Push2(SqStack2 &S2,float e);//声明入压栈函数char GetTop1(SqStack1 &S1);//声明取栈顶元素函数float GetTop2(SqStack2 &S2);//声明取栈顶元素函数char Pop1(SqStack1 &S1);//声明出栈函数float Pop2(SqStack2 &S2);//声明出栈函数char Compare(char m,char n);//声明比较函数float Operate(float a,char rheta,float b);//声明运算函数void DispStack1(SqStack1 &S1);//从栈底到栈顶依次输出各元素void DispStack2(SqStack2 &S2);//从栈底到栈顶依次输出各元素/*主函数*/void main(){SqStack1 S1;//定义运算符栈SqStack2 S2;//定义运算数栈//freopen("data1.in","r",stdin);//freopen("data1.out","w",stdout);InitStack1(S1);//调用栈建立函数InitStack2(S2);//调用栈建立函数evaluate(S1,S2);//调用确定如何入栈函数cout<<"按任意键结束!"<<endl;}/*运算符栈函数*/void InitStack1(SqStack1 &S1)//构造一个空栈S1{S1.base=(char *)malloc(STACK_INIT_SIZE *sizeof(char));if(!S1.base)cout<<"存储分配失败!";//存储分配失败S1.top=S1.base;S1.stacksize=STACK_INIT_SIZE;}void Push1(SqStack1 &S1,char e)//入栈{if(S1.top-S1.base>=S1.stacksize)//如果栈满,追加存储空间{S1.base=(char *)realloc(S1.base,(S1.stacksize+STACKINCREMENT)*sizeof(char));if(!S1.base) cout<<"存储分配失败!";else{S1.top=S1.base+S1.stacksize;S1.stacksize=S1.stacksize+STACKINCREMENT;}}*S1.top=e;S1.top=S1.top+1;//将元素压入栈中,指针上移}char GetTop1(SqStack1 &S1)//取栈顶元素{char e;if(S1.top==S1.base)cout<<"\n\t\t\t运算符栈已空!\n";else e=*(S1.top-1);return e;}void DispStack1(SqStack1 &S1)//从栈底到栈顶依次输出各元素{char e,*p;if(S1.top==S1.base)cout<<" ";else{p=S1.base;while(p<S1.top){e=*p;p++;cout<<e;}}}char Pop1(SqStack1 &S1)//出栈{char e;if(S1.top==S1.base)cout<<"\n\t\t\t运算符栈已空!\n";e=*(--S1.top);return e;}/*运算数栈函数*/void InitStack2(SqStack2 &S2)//构造一个空栈S2{S2.base=(float *)malloc(STACK_INIT_SIZE *sizeof(float));if(!S2.base)cout<<"存储分配失败!";//存储分配失败S2.top=S2.base;S2.stacksize=STACK_INIT_SIZE;}void Push2(SqStack2 &S2,float e)//入栈{if(S2.top-S2.base>=S2.stacksize)//栈满,追加存储空间{S2.base=(float *)realloc(S2.base,(S2.stacksize+STACKINCREMENT)*sizeof(float));if(!S2.base)cout<<"存储分配失败!";else{S2.top=S2.base+S2.stacksize;S2.stacksize=S2.stacksize+STACKINCREMENT;}}*S2.top=e;S2.top=S2.top+1;//将元素e入栈,指针上移}void DispStack2(SqStack2 &S2)//从栈底到栈顶依次输出各元素{float e,*p;if(S2.top==S2.base)cout<<" ";elsep=S2.base;while(p<S2.top){e=*p;p++;cout<<e;}}}float GetTop2(SqStack2 &S2)//取栈顶元素{float e;if(S2.top==S2.base) cout<<"\n\t\t运算数栈已空!";else e=*(S2.top-1);return e;}float Pop2(SqStack2 &S2)//出栈{float e;if(S2.top==S2.base)cout<<"\n\t\t运算数栈已空!";e=*(--S2.top);return e;}/*确定如何入栈函数*/void evaluate(SqStack1 &S1,SqStack2 &S2){char c;float t,e;int n=0,i=1,j=0,k=0,l=0;char ch[STACK_INIT_SIZE];int s=1;int flag=0,flag2=0;float p1,p2;char ch1;Push1(S1,'#');//将'#'入栈,作为低级运算符cout<<"●请输入不含变量的表达式(以#结束!):\n ";cin>>ch;c=ch[0];cout<<"\n●对表达式求值的操作过程如下:"<<"\n______________________________________________________________________________ __\n"<<"步骤\t运算符栈S1\t运算数栈S2\t输入字符\t\t主要操作";while(c!='#'||GetTop1(S1)!='#')cout<<"\n__________________________________________________________________________ ______\n";cout<<i++<<"\t";DispStack1(S1);cout<<"\t\t";DispStack2(S2);cout<<"\t\t";if(flag==1){k--;flag=0;}if(flag2){k+=flag2;flag2=0;}for(l=0;l<k;l++)cout<<' ';for(j=k;ch[j]!='\0';j++)cout<<ch[j];if(ch[k]!='#'&&flag!=1) {k++;flag=0;}as:if(!(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='#')){//输入的字符如果不是运算符号,则继续输入直到输入的是运算符为止,将非运算符转换成浮点数if(!(c=='.')&&n>=0){e=float(c-48);n++;if(n==1)t=e;else if(n>1)t=t*10+e;c=ch[s++];}if(n==-1){e=float(c-48);t=t+e/10;c=ch[s++];}if(c=='.'){n=-1;c=ch[s++];}if((c>='0'&&c<='9')||c=='.'){flag2++;goto as;}if(c<'0'||c>'9'){Push2(S2,t);}cout<<"\t\tPush2(S2,"<<t<<")";}else//输入的是运算符{n=0;//非运算型数据计数器清零switch(Compare(GetTop1(S1),c))//比较运算符的优先级{case '<'://栈顶元素优先级低,则入栈且继续输入Push1(S1,c);cout<<"\t\tPush1(S1,"<<c<<")";c=ch[s++];break;case '='://栈顶元素优先级相等,脱括号并接收下一字符Pop1(S1);cout<<"\t\tPop1(S1)";c=ch[s++];break;case '>'://栈顶元素优先级高,则退栈并将运算结果入栈p1=Pop2(S2);p2=Pop2(S2);ch1=Pop1(S1);Push2(S2,Operate(p2,ch1,p1));cout<<"\t\tOperate("<<p2<<','<<ch1<<','<<p1<<')';flag=1;break;}}}cout<<"\n________________________________________________________________________________\n";cout<<i<<'\t'<<'#'<<"\t\t"<<GetTop2(S2)<<"\t\t";for(j=0;j<k;j++) cout<<' ';cout<<"#"<<"\t\t"<<"RETURN(GETTOP(S2))";cout<<"\n__________________________________________________________________________ ______\n";if(S2.top-1==S2.base)//显示表达式最终结果cout<<"\n●表达式的结果为:"<<GetTop2(S2)<<endl;else cout<<"\n表达式出错!\n";}char Compare(char m,char n)//运算符的优先级比较{if(n=='+'||n=='-')//输入符号为"+"、"-"{if(m=='('||m=='#')return '<';//栈顶元素为"("、"#",此时栈顶符号优先级低,返回"<"else return '>';//否则,栈顶符号优先级高,返回">"}else if(n=='*'||n=='/')//输入的符号为"*"、"/"{if(m==')'||m=='*'||m=='/')return '>';//栈顶元素为")"、"*"、"/",此时栈顶符号优先级高,返回">"else return '<';//否则,栈顶符号优先级低,返回"<"}else if(n=='(')return'<';//输入的符号为"(",则直接返回"<"else if(n==')')//输入的符号为")"{if(m=='(')return'=';//栈顶元素为"(",此时优先级同,返回"="else return '>';//否则,栈顶符号优先级高,返回">"}else //输入符号为其他{if(m=='#')return'=';//栈顶元素为"#",此时优先级同,返回"="else return '>';//否则,栈顶符号优先级高,返回">"}}float Operate(float a,char theta,float b)//运算函数{float tmp=0;if (theta=='+')tmp=a+b;//从运算符栈取出的符号为"+",则运算数栈的两元素相加,并返回else if(theta=='-')tmp=a-b;//从运算符栈取出的符号为"-",则运算数栈的两元素相减,并返回else if(theta=='*')tmp=a*b;//从运算符栈取出的符号为"*",则运算数栈的两元素相乘,并返回else if(theta=='/') //从运算符栈取出的符号为"/",则运算数栈的两元素相除,并返回{if(b==0) cout<<"\n表达式出错!除数不能为0!\n";else tmp=a/b;}return tmp;}五、运行与测试第六章总结与心得数据结构的研究不仅涉及到计算机硬件的研究,而且和计算机软件的研究有着更密切的关系,无论是编译程序还是操作系统,都涉及到数据元素在存储器中的分配问题。

相关文档
最新文档