数据结构(表达式求值)课程设计
算术表达式的求解-数据结构课程设计报告
算术表达式的求解-数据结构课程设计报告课程设计报告题目:算术表达式求值一、需求分析 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)。
数据结构课程设计算术表达式求值-计算器(Word)
高级语言程序设计《算术表达式求值》课程设计报告算术表达式求值系统可以实现实现对算术四则混合运算表达式求值,并打印求值过程中运算符栈、操作数栈的变化过程。
第二章系统分析开始运行时界面如下:你可以输入一个表达式,按E对其进行求值。
#include <stdio.h>#include <conio.h>#include <stdlib.h>#include <string.h>#define N 100double numStack[N]={0};//操作数栈int numTop;char opStack[N];//运算符栈int opTop;void print_num(double str1[],int n) {int i;printf("\n操作数栈:\n");for(i=0;i<n;i++)printf("%g ",str1[i]);}void print_op(char str2[],int m) {int j;printf("\n运算符栈:\n");for(j=0;j<m;j++)printf("%c ",str2[j]);}int op(char ch)//判断运算符优先级{if(ch=='+'||ch=='-') return 2;if(ch=='*'||ch=='/') return 3;if(ch=='(') return -1;return 0;}double result(double num1,char op,double num2)//计算{if(op=='+') return num1+num2;if(op=='-') return num1-num2;if(op=='*') return num1*num2;if(op=='/') return num1/num2;return 0;}int compute(char str[]){double num=0;int i=0,j=1,k=1;numTop=opTop=0;while(str[i]!='\0'||opTop>0){if(str[i]>='0'&&str[i]<='9')num=num*10+str[i]-'0';else if( k==1&&str[i]=='-'&&(i==0||op(str[i-1])) )k=-1;else{if(i>0&&!op(str[i-1])&&str[i]!='('&&str[i-1]!=')') {numStack[numTop++]=num*k;if(opTop!=0&&numTop!=0)print_num(numStack,numTop);num=0; j=1; k=1;}if(opTop==0||str[i]=='('){opStack[opTop++]=str[i];print_op(opStack,opTop);}else if(str[i]==')'){while(opTop>0&&opStack[--opTop]!='('){numStack[numTop-2]=result(numStack[numTop-2],opStack[opTop],numStack[numTop-1]);if(opTop!=0&&numTop!=0){print_num(numStack,numTop);print_op(opStack,opTop);}numTop--;}if(opStack[opTop]!='(') return 0;}else{if(str[i]=='\0'&&numTop==0) return 0;while(opTop>0&&op(str[i])<=op(opStack[opTop-1])){numStack[numTop-2]=result(numStack[numTop-2],opStack[--opTop],numStack[numTop-1]);if(opTop!=0&&numTop!=0){print_num(numStack,numTop-1); print_op(opStack,opTop);}numTop--;}if(str[i]!='\0')opStack[opTop++]=str[i];if(opTop!=0&&numTop!=0)print_op(opStack,opTop);}}if(str[i]!='\0')i++;}if(numTop!=1||opTop!=0)return 0;return 1;}void menu(){system("cls");printf("_______________________________\n");printf(" Clear(C) | Equal(E) | Quit(Q) \n");printf("-------------------------------\n");}int main(void){int i=0,j=0,k;char str[N]="\0";char num[N]="\0";char save[N]="\0";char ch;double temp;unsigned long temp2;menu();printf("input an expression,press key 'E' to compute\n");ch=getch();while( 1 ){if(ch==')'||op(ch)||ch>='0'&&ch<='9'){str[i++]=ch;str[i]='\0';menu();printf("input an expression,press key 'E' to compute\n"); printf("%s",str);if( ch=='-'&&(i==1||op(str[i-2]))||ch>='0'&&ch<='9' ){num[j++]=ch;num[j]='\0';}elsej=0;}if(ch=='C'||ch=='c'){if(strlen(str))str[--i]='\0';menu();printf("input an expression,press key 'E' to compute\n");printf("%s",str);}if(ch=='E'||ch=='e'){if(compute(str)){printf("\n=%g\n",numStack[0]); j=0; temp=numStack[0];if(temp<0){temp=-temp;num[j++]='-';num[j]='\0';}temp2=(unsigned long)temp;k=1;while(temp2/k>=10) k*=10;while(k){num[j++]=temp2/k+'0';num[j]='\0';temp2=temp2%k;k/=10;}temp=temp-(int)temp;if(temp!=0){num[j++]='.';num[j]='\0';temp+=0.0000005;}for(k=6;k>0;k--){if(temp==0) break;temp*=10;num[j++]=(int)temp+'0';num[j]='\0';temp=temp-(int)temp;}}i=0; j=0; str[0]='\0';}if(ch=='Q'||ch=='q'){printf("\nare you sure to quit?(Y/N)\n");ch=getch();if(ch=='Y'||ch=='y') break;else{menu();printf("input an expression,press key 'E' to compute\n");printf("%s",str);}}ch=getch();}return 0;}第五章系统测试1.先输入: 3+2*5 后按E求值2.再输入:12/4-5 后按E求值3.再输入Q4.输入Y,退出系统。
数据结构课程设计报告-表达式求值
《数据结构》课程设计利用栈求表达式的值班级: 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语⾔版) 明⼈不说暗话,直接上,输⼊提取码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【实现效果】完全可以实现题目的要求,除了下图的错误提示,本程序还可以提示的错误有:输入过多运算符,缺少反括号,两个括号之间缺少运算符相连,缺少左括号,输入的运算符超出范围等提示。
数据结构课程设计报告-中缀算术表达式求值
课程设计报告课程名称数据结构课题名称中缀算术表达式求值专业通信工程班级通信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. 问题描述表达式是数据运算的基本形式。
人们的书写习惯是中缀式,如: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)顺序栈入栈:入栈需要在栈顶插入一个新元素并相应的调整栈顶。
数据结构课程设计报告(二)表达式求值(计算器)
课程设计报告课程名称:数据结构课程设计设计题目:表达式求值(计算器)学院:信息科学与工程学院专业:计算机科学与技术(软件外包)姓名:指导教师:二零一五年十二月二十九日一、设计容与要求1、问题描述设计一个算术计算器,能运算包括四则运算、括号的表达式的运算。
2、设计要求实现()、+、-、*、/、^ 等运算,实现小数和整数混合运算,优先级的处理,能判断算术表达式是否正确等。
二、算法设计1、输入并建立表达式,运用数组结构体构建将整型数字与操作符结合定义运算符的优先级。
typedef struct yxj{char operat;int rank;}yxj;2、分别建立一个操作数栈和操作符栈存放数字和操作符,定义操作符栈第一个元素优先级最低。
3、自左向右扫描字符串遇到字符串中的数字时一律提取转换成double型存入操作数栈。
遇到操作符时,则将当前运算符的优先级数与运算符栈顶元素的优先级数相比较。
若当前运算符的优先级数大,则进栈;反之,则取出栈顶的运算符,并在数栈中连续取出两个栈顶元素作为运算对象进行运算,并将运算结果存入数栈,然后继续比较当前运算符与栈顶元素的优先级。
直到当前运算符进栈。
4、对比运算符进行+ - * /()^ 运算。
三、程序代码#include<stdio.h>#include<stdlib.h>#include<string.h>#include<math.h>#define N 100typedef struct yxj{char operat;int rank;}yxj;typedef struct str{char data[N];}zs;void szys(yxj mark[]){yxj os[N];char ch;double ns[N];zs zhan[20];int numb[N];int Len,p=0,q=1,i,o=1,n=0;char data[N];os[0]=mark[0];printf("请输入算术(+ - * / ^)表达式(以 = 结束):\n");scanf("%s",data);Len=strlen(data);numb[0]=0;for(i=0;i<20;i++)zhan[i].data[0]='\0';for(i=0;i<Len;i++){int t=0;if(data[i]=='^'||data[i]=='+'||data[i]=='-'||data[i]=='*'||data[i]=='/'||data[ i]=='('||data[i]==')'||data[i]=='='){int j,k=0;if((data[i]=='='||data[i]=='^'||data[i]=='+'||data[i]=='-'||data[i]=='*'||data [i]=='/')&&(data[i-1]=='^'||data[i-1]=='+'||data[i-1]=='-'||data[i-1]=='*'||data[i -1]=='/')){printf("格式错误\n");return;}numb[q++]=i;while(zhan[(p+k)/2].data[0]!='\0'){k++;}for(j=numb[q-2];j<numb[q-1];j++)if(data[j]>='0'&&data[j]<='9'||data[j]=='.')zhan[(p+k)/2].data[t++]=data[j];zhan[(p+k)/2].data[t]='\0';if(zhan[(p+k)/2].data[0]!='\0')ns[n++]=atof(zhan[(p+k)/2].data);p++;for(j=0;j<8;j++)if(mark[j].operat==data[i])break;while(1){if(mark[j].operat=='('){os[o++]=mark[j];break;}else if(mark[j].rank>os[o-1].rank&&mark[j].operat!='(') {os[o++]=mark[j];break;}else{double numb1,numb2,numb;ch=os[--o].operat;if(ch=='+'){numb1=ns[--n];numb2=ns[--n];numb=numb1+numb2;ns[n++]=numb;}if(ch=='-'){numb1=ns[--n];numb2=ns[--n];numb=numb2-numb1;ns[n++]=numb;}if(ch=='*'){numb1=ns[--n];numb2=ns[--n];numb=numb2*numb1;ns[n++]=numb;}if(ch=='/'){numb1=ns[--n];numb2=ns[--n];if(numb1==0){printf("无效操作\n");return;}else{numb=numb2/numb1;ns[n++]=numb;}}if(ch=='^'){numb1=ns[--n];numb2=ns[--n];numb=pow(numb2,numb1);ns[n++]=numb;}}}}else if(data[i]>='0'&&data[i]<='9');else if(data[i]=='.');else{printf("格式错误,请重新输入:\n");szys(mark);break;}}printf("%lf\n",ns[0]);}int main (){yxj mark[9];mark[0].operat='#';mark[0].rank=-1;mark[1].operat='+';mark[1].rank=1;mark[2].operat='-';mark[2].rank=1;mark[3].operat='*';mark[3].rank=2;mark[4].operat='/';mark[4].rank=2;mark[5].operat='(';mark[5].rank=-1;mark[6].operat=')';mark[6].rank=-1;mark[7].operat='=';mark[7].rank=0;mark[8].operat='^';mark[8].rank=3;while(1){char i[N];printf("*****1、计算器*****\n");printf("*****0、退出 *****\n");scanf("%s",&i);if(strcmp(i,"0")==0)break;else if(strcmp(i,"1")==0)szys(mark);elseprintf("没有该选项\n");}}四、运行测试1.正常四则运算2.乘方运算3.除数为零时4.格式出现错误5.小数运算五、结论这次课程设计让我们更加了解大一学到的C和这个学期学到的数据结构。
数据结构课程设计说明书(表达式求值)
**大学数据结构课程设计说明书学生姓名:***学号: **********学院: **********学院专业: 网络工程题目: 利用栈求表达式的值成绩指导教师******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,用于存放操作符。
数据结构课程设计算术表达式求值
计算机科学系《数据结构课程设计》报告课题名称:算术表达式求值目录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栈中加入一个‘=‘。
数据结构课设 表达式求值
《计算表达式》课程设计报告标题:计算表达式单位:报告人:指导教师:编程环境: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语言版)课程设计报告表达式求值说明书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.前言 (2)2.问题描述 (3)3.总体设计··········································································错误!未定义书签。
3.1 概要设计 ······································································错误!未定义书签。
数据结构课程设计表达式求值问题
课程设计(论文)题目名称表达式求值问题课程名称数据结构课程设计学生姓名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)该程序实现表达式的求值问题:从键盘读入一个合法的算术表达式,利用算符优先关系,实现对算术四那么混合运算的求值,输出正确的结果。
数据结构课程设计报告(二)表达式求值(计算器).doc
数据结构课程设计报告(二)表达式求值(计算器).课程设计报告课程名称:数据结构课程设计设计题目:表达式求值(计算器)学院:信息科学与工程学院专业:计算机科学与技术(软件外包)姓名:指导教师:二零一五年十二月二十九日word教育资料.一、设计内容与要求1、问题描述设计一个算术计算器,能运算包括四则运算、括号的表达式的运算。
2、设计要求实现()、+、- 数据结构课程设计设计题目:表达式求值(计算器)学院:信息科学与工程学院专业:计算机科学与技术(软件外包)姓名:指导教师:二零一五年十二月二十九日word教育资料.一、设计内容与要求1、问题描述设计一个算术计算器,能运算包括四则运算、括号的表达式的运算。
2、设计要求实现()、+、:\n"); scanf("%s",data); Len=strlen(data); numb[0]=0; for(i=0;i20;i++) zhan[i].data[0]='\0'; for(i=0;i='0'data[i]='9'); else if(data[i]=='.'); else { printf("格式错误,请重新输入:\n"); szys(mark); break; } } printf("%lf\n",ns[0]);}int main (){ yxj mark[9]; mark[0].operat='#'; mark[0].rank=-1; mark[1].operat='+'; mark[1].rank=1; mark[2].operat='-'; mark[2].rank=1; mark[3].operat='*'; mark[3].rank=2; mark[4].operat='/'; mark[4].rank=2; mark[5].operat='('; mark[5].rank=-1; mark[6].operat=')'; mark[6].rank=-1; mark[7].opera该选项\n"); }}四、运行测试1.正常四则运算2.乘方运算3.除数为零时4.格式出现错误5.小数运算五、结论这次课程设计让我们更加了解大一学到的C和这个学期学到的数据结构。
施磊磊的数据结构课程设计及报告2 表达式求值问题
课程设计题目名称表达式求值问题课程名称数据结构课程设计学生姓名施磊磊学号0813022057班级计082指导教师管致锦数据结构课程设计及报告表达式求值一、问题描述实验题目为表达式求值。
要求接受用户输入一个中缀表达式(运算符为加、减、乘、除),然后通过借助于顺序栈实现将其转换为后缀表达式并将其打印,最后求出其值。
设计主函数,使用户可以重复输入中缀表达式,求得表达式的后缀表达式和表达式的值。
二、数据结构算法设计(一)堆栈ADTADT Stack{数据:0个或多个元素的线性序列(a0,a1,...,an-1),其最大允许长度为MaxStackSize。
运算:Create(): 建立一个空栈。
Destroy(): 撤销一个栈。
IsEmpty(): 若空栈,则返回true;否则返回false。
IsFull(): 若栈满,则返回true;否则返回false。
Top(): 在x中返回栈顶元素。
若操作成功,则返回true;否则返回false。
Push(): 在栈顶插入元素x(入栈)。
若操作成功,则返回true;否则返回false。
Pop(): 从栈中删除栈顶元素(出栈)。
若操作成功,则返回true;否则返回false。
Clear(): 清除堆栈中全部元素。
}(二)顺序栈类在此题目中,借助了c++的模板抽象类来定义栈抽象数据类型,程序如下:顺序堆栈类:includetemplateclass Stack{private:T * stack; //指向数组的指针int top; //栈顶指针int maxTop; //最大栈顶指针public:Stack(); //构建一个构造函数;初始化栈void Push(T item); //进栈T Pop(); //出栈,删除栈顶元素T Peek(); //返回栈顶元素bool EmptyStack(); //判断是否为空栈~Stack() {delete []stack;}; //释放并清空栈的存储空间void Clear(){top=-1;} //清除栈中全部元素三、算法原理(一)头文件名在本程序中,运用的头文件有一些是在平时经常用到的,也有一些是少见甚至是很陌生的。
数据结构课程设计-算术表达式求值的实现
课程设计报告课程设计名称:数据结构课程设计课程设计题目:算术表达式求值的实现院(系):*****专业:*****班级:*****学号:*****姓名:*****指导教师:*****目录1 课程设计介绍 (1)1.1课程设计内容 (1)1.2课程设计要求 (1)2 课程设计原理 (2)2.1课设题目粗略分析 (2)2.2原理图介绍 (2)2.2.1 功能模块图 (2)2.2.2 流程图分析 (3)3 数据结构分析 (5)3.1存储结构 (5)3.2算法描述 (5)4 调试与分析 (7)4.1调试过程 (7)4.2程序执行过程 (7)参考文献 (8)附录(关键部分程序清单) (9)1 课程设计介绍1.1 课程设计内容编写算法能够进行整型和实型数的表达式求值,能够根据运算的数据选择正确的运算结果的数据类型,表达式的运算符为:+,—,*,/,(,),且括号可以嵌套。
1.2 课程设计要求1.给出必要的输入、输出信息和提示信息。
2.参考相应的资料,独立完成课程设计任务。
3.交规范课程设计报告和软件代码。
2 课程设计原理2.1 课设题目粗略分析根据课设题目要求,拟将整体程序分为三大模块。
此三个模块相互独立,没有嵌套调用的情况,以下是三个模块的大体分析:1.首先依次定义字符类型栈、整型栈、运算符栈和操作数栈,构造运算符栈和操作数栈,然后运算符、操作数依次入栈。
2. 依次读入表达式,若是操作符即进OPND栈,若是运算符即进OPTR栈。
顺序栈的存储结构是利用一组连续的存储单元依次存放自栈底到栈顶的数据元素,同时附设指针top指示栈顶元素在顺序栈中的位置,base为栈底指针,在顺序栈中,它始终指向栈底,即top=base可作为栈空的标记,每当插入新的栈顶元素时,指针top增1,删除栈顶元素时,指针top减1。
3. 按照运算符的优先级别对表达式进行求值运算。
2.2 原理图介绍该功能模块图介绍了这个程序的主要功能。
2.2.1 功能模块图图2.1功能模块图如图2.1所示,要实现表达式的求值,即必须要实现存储、读取和计算三项功能。
数据结构课程设计带括号的算术表达式求值
数据结构课程设计带括号的算术表达式求值、实验的⽬的和要求1.采⽤算符优先数算法, 能正确求值表达式;2.熟练掌握栈的应⽤;3?熟练掌握计算机系统的基本操作⽅法,了解如何编辑、编译、链接和运⾏⼀个C++程序; 4.上机调试程序,掌握查错、排错使程序能正确运⾏。
三、实验的环境:指硬件和软件环境1.硬件环境: Intel 奔腾双核T2390 双核处理器(1.86GHz 主频/1MB ⼆级缓存/533MHz 前端总线), RAM:2G .2.软件环境: 操作系统:windows vista编译软件:Microsoft Viual C++6.03.软件环境介绍:Visual C++是⼀个功能强⼤的可视化软件开发⼯具。
⾃1993年Microsoft公司推出Visual C++1.0后,随着其新版本的不断问世,Visual C++已成为专业程序员进⾏软件开发的⾸选⼯具。
虽然微软公司推出了Visual C++.NET(Visual C++7.0) ,但它的应⽤的很⼤的局限性,只适⽤于Windows 2000,Windows XP 和Windows NT4.0。
所以实际中,更多的是以Visual C++6.0 为平台。
Visual C++6.0不仅是⼀个C++编译器,⽽且是⼀个基于Windows操作系统的可视化集成开发环境( integrated development environment,IDE )。
Visual C++6.0 由许多组件组成,包括编辑器、调试器以及程序向导AppWizard 、类向导Class Wizard 等开发⼯具。
这些组件通过⼀个名为Developer Studio 的组件集成为和谐的开发环境。
四、算法描述:1.头⽂件:Stack.hCalculator.hMethod:Stack method:Push(); // 进栈操作Pop(); // 出栈操作GetHead(); // 返回栈中的最顶层元素MakeEmpty(); // 清空栈操作Calculator method:Calculator();// 计算主体celarstream(); // 清空输⼊流Prior();// 返回运算符的优先级done(); // 做⼀次⼆元运算output(); // 打印结果并输出EnEmpty(); // 调⽤MakeEmpty(), 并清空栈2.cpp ⽂件Calculator.cppMethod:3.程序流程图优先级⽐较算法Data 算法存放操作字符存放数据调⽤ Calculator 。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
#*(
3 5
)#
CPop(OPF)
9
#*
3 5
#
Operate(‘3’,’*’,5’)
10
#
15
#
Return(GetTop(OPS))
表一
4.4.
附录一:测试数据
组别
表达式
正确值
1
12+(9-8)*7-(-6*5)
49
2
3.14*(67.305-65.305)+3.14
9.42
3
3+{2*[2*(3+4)]}
1.首先置操作数栈为空栈,表达式起始符”#”为运算符栈的栈底元素;
2.依次读入表达式,若是操作符即进OPS栈,若是运算符则和OPF栈的栈顶运算符比较优先权后作相应的操作,直至整个表达式求值完毕(即OPF栈的栈顶元素和当前读入的字符均为”#”)。
4.
4.1
本程序所做的工作为:能直接求出四则表达式的值,并输出;本程序可用于小学教师对学生作业的快速批改以及对数值位数要求较大的科学运算。
2
#
3
*(7-2)#
CPush(OPF,’*’)
3
#*
3
(7-2)#
CPush(OPF,’(’)
4
#*(
3
7-2)#
Push(OPS,’7’)
5
#*(
3 7
-2)#
CPush(OPF,’-’)
6
#*(-
3 7
2)#
Push(OPS,’2’)
7
#*(-
3 7 2
)#
Operate(‘7’,’-’,’2’)
{if(运算符为‘-’&&运算符前一个为‘(’)
{c=*p;
temp=p;
p++;
}
else
{调用函数CGetTop(OPF,ch)得到OPF的栈顶元素;
switch(调用函数Precede(ch,c)判断栈顶元素与接收的字符的优生级别)
{
case栈顶运算符优先权低:
调用函数CPush(OPF,c)将c入运算符栈;
操作结果:用e返回head的栈顶元素
(6)CDestroyStack(LinkCharStack &head)
初始条件:栈head已存在
操作结果:栈head被销毁
}ADT LinkCharStack
3.系统中子程序及功能要求:
Comop(char ch):判断输入的字符是否为运算符
char Precede(char ch,char c):比较两个运算符的优先级,ch是栈顶字符,c是表达式字符。
}//else1
}//else2
}//退出最外层while循环
调用函数GetTop(OPS,i)得到栈顶元素i;
将两个栈消毁;
}EvaluateExpression函数结束
利用该算法对算术表达式3*(7-2)求值操作过程如下:
步骤
OPF栈
OPS栈
输入表达式
主要操作
1
#
3*(7-2)#
Push(OPS,’3’)
while(p指针不指向’.’)
{
将p指向的字符转为小数n
p--;
}
p=q;
p++;
}
if(运算符为‘-’并且运算符前一个为‘(’或者为表达式的开始)
调用Push(OPS,-(m+n))将m+n的相反数入栈;
else
调用Push(OPS,m+n)将m+n入栈;
}数字进栈结束
else//是运算符时则进栈OPF
定义一个运算符栈OPF;
定义一个操作数栈OPS;
调用函数InitStack()初始化栈OPS;
调用函数CInitCharStack()初始化栈OPF;
调用函数CPush(OPF,'#')将#压入运算符栈;
c=*p;temp=p;p++;
if(第一个字符就为‘-’)
{
c=*p;temp=p;p++;
}
接收下一个字符;
case栈顶运算符优先权高:
运算符出栈得到ch;
数字栈连续出栈两次得到a,b ;
调用Operate(a,ch,b)并将结果入栈到数字栈;break;
case优生权相等:脱括号并接收下一个字符;
调用CPop(OPF,ch)脱括号;接收下一个字符;
default:接收下一个字符;
}退出switch循环
31
4
4.3-{2.5*[9.9/(1.1+2.2)]}
-3.2
5
12-(3-6*7)8-4
错误表达式
表二
按照附录中的测试数据,得出如下测试、分析结果:
当我们输入表格中两个正确的四则表达式时程序能准确地求得其值:
完全支持浮点数,正负数的运算;
而当我们输入第五组错误的表达式时,程序能做出正确判断,提醒用户输入的表达式错误。
操作结果:构造一个空栈head
(2)CIsEmpty(LinkCharStack head)
初始条件:栈head已存在
操作结果:若栈为空栈,则返回TRUE,否则FALSE
(3)CPush(LinkCharStack &head,ElementType element)
初始条件:栈head已存在
操作结果:插入元素element为新的栈顶元素
ElementType Operate(ElementType a,char ch,ElementType b):解析表达式中的双目运算,其返回的结果即为双目运算表达式的值。
int error(char *str):错误提示函数,实现对多种非法四则表达式的判断,并给出提示,让用户更正自己的输入错误。
子程序7可调用子程序1,2,3,4。
4.3.
此算法的基本思想:
首先置操作数栈OPS为空栈,表达式起始符“#”为运算符的栈底元素;依次读入表达式中每个字符,若是操作数则进栈,若是运算符则和OPF栈的栈顶运算符比较优先权作相应操作,直至整个表达式求值完毕(即OPF栈的栈顶元素和当前读入的字符均为“#”)
# include <string.h>
#define ERROR 0
#define OK 1
#defineTRUE 1
#define FALSE 0
typedef char ElemType;
typedef int Status;
typedef double ElementType;
typedef int Status;
void InitStack(LinkStack &head){
head=(LinkStack)malloc(sizeof(StackNode));
初始条件:栈head已存在且非空
操作结果:删除head的栈顶元素,并用e返回其值
(5)GetTop(LinkStack head, ElementType &element)
初始条件:栈head已存在并且非空
操作结果:用e返回head的栈顶元素
(6)DestroyStack(LinkStack &head)
# define STACK_INIT_SIZE 30
# define STACKINCREAMENT 10
# define NUMBER 30
typedef struct node{
ElementType data;
struct node *next;
}StackNode, *LinkStack;
初始条件:栈head已存在
操作结果:若栈为空栈,则返回TRUE,否则FALSE
(3)Push(LinkStack &head,ElementType element)
初始条件:栈head已存在
操作结果:插入元素element为新的栈顶元素
(4)Pop(LinkStack &head,ElementType &element)
初始条件:栈head已存在
操作结果:栈head被销毁
}ADT LinkStack
2.//用于存储运算符(OPF):
ADT LinkCharStack{
数据对象D:元素类型为字符型的符号字符
数据关系R:
基本操作:栈中数据元素之间是线性关系。
(1)CInitStack(LinkCharStack &head)
void MenuPrint():主菜单打印函数。
void Clear():清屏函数。
ElementType EvaluateExpression(char *exp):这是此程序的核心函数,可以综合其它子函数,实现最终的表达式求解。
各程序模块之间的调用关系(子程序编号见上):
主函数可调用子程序5,6,7。
程序设计时,也不要怕遇到错误,在实际操作过程中犯的一些错误还会有意外的收获,感觉课程设计很有意思。在具体操作中这学期所学的数据结构的理论知识得到巩固,达到课程设计的基本目的,也发现自己的不足之出,在以后的上机中应更加注意。
6.
//这个栈是用来存储数字字符的
#include<stdlib.h>
# include <stdio.h>
课程设计报告
课程名称:
数据结构课程设计
课程设计题目:
表达式求值问题
姓名:
系:
计算机科学与技术
专业:
计算机科学与技术
年级:
2011级
学号:
指导教师:
职称: