数据结构表达式求值完整篇(含实验报告)
(完整word版)数据结构表达式求值实验报告
《数据结构》课程设计报告书题目: 表达式求值系别：计算机科学与信息系学号：学生姓名：指导教师:完成日期:目录➢1.前言➢2.概要设计2。
1 数据结构设计2.2 算法设计2.3 ADT描述2。
4 功能模块分析➢3。
详细设计3.1 数据存储结构设计3.2主要算法流程图（或算法代码）➢4.软件测试➢5。
总结➢附录1．前言在计算机中，算术表达式由常量、变量、运算符和括号组成。
由于不同的运算符具有不同的优先级，又要考虑括号，因此，算术表达式的求值不可能严格地从左到右进行.因而在程序设计时，借助栈实现。
算法输入：一个算术表达式,由常量、变量、运算符和括号组成（以字符串形式输入）。
为简化，规定操作数只能为正整数，操作符为+、-*、/，用#表示结束。
算法输出：表达式运算结果。
算法要点：设置运算符栈和运算数栈辅助分析算符优先关系。
在读入表达式的字符序列的同时,完成运算符和运算数的识别处理，以及相应运算。
2．概要设计2.1 数据结构设计任何一个表达式都是由操作符,运算符和界限符组成的。
我们分别用顺序栈来寄存表达式的操作数和运算符.栈是限定于紧仅在表尾进行插入或删除操作的线性表。
顺序栈的存储结构是利用一组连续的存储单元依次存放自栈底到栈顶的数据元素，同时附设指针top指示栈顶元素在顺序栈中的位置，base为栈底指针，在顺序栈中，它始终指向栈底，即top=base可作为栈空的标记，每当插入新的栈顶元素时，指针top增1，删除栈顶元素时,指针top减1。
2.2 算法设计为了实现算符优先算法。
可以使用两个工作栈。
一个称为OPTR ，用以寄存运算符，另一个称做OPND ，用以寄存操作数或运算结果。
1。
首先置操作数栈为空栈，表达式起始符”＃"为运算符栈的栈底元素；2.依次读入表达式，若是操作符即进OPND 栈，若是运算符则和OPTR 栈的栈顶运算符比较优先权后作相应的操作，直至整个表达式求值完毕（即OPTR 栈的栈顶元素和当前读入的字符均为"#")。
数据结构表达式求值实验报告
竭诚为您提供优质文档/双击可除数据结构表达式求值实验报告篇一：数据结构实验二——算术表达式求值实验报告《数据结构与数据库》实验报告实验题目算术表达式求值学院：化学与材料科学学院专业班级：09级材料科学与工程系pb0920603姓学邮名：李维谷号：pb09206285箱：指导教师：贾伯琪实验时间：20XX年10月10日一、需要分析问题描述：表达式计算是实现程序设计语言的基本问题之一，它的实现是栈的应用的一个典型例子。
设计一个程序，演示通过将数学表达式字符串转化为后缀表达式，并通过后缀表达式结合栈的应用实现对算术表达式进行四则混合运算。
问题分析：在计算机中，算术表达式由常量、变量、运算符和括号组成。
由于不同的运算符具有不同的优先级，又要考虑括号，因此，算术表达式的求值不可能严格地从左到右进行。
因而在程序设计时，借助栈实现。
设置运算符栈（字符型）和运算数栈（浮点型）辅助分析算符优先关系。
在读入表达式的字符序列的同时完成运算符和运算数的识别处理，然后进行运算数的数值转换在进行四则运算。
在运算之后输出正确运算结果，输入表达式后演示在求值中运算数栈内的栈顶数据变化过程，最后得到运算结果。
算法规定：输入形式：一个(:数据结构表达式求值实验报告)算术表达式，由常量、变量、运算符和括号组成（以字符串形式输入）。
为使实验更完善，允许操作数为实数，操作符为（、）、.（表示小数点）、+、-、*、/、^（表示乘方），用#表示结束。
输出形式：演示表达式运算的中间结果和整个表达式的最终结果，以浮点型输出。
程序功能：对实数内的加减乘除乘方运算能正确的运算出结果，并能正确对错误输入和无定义的运算报错，能连续测试多组数据。
测试数据：正确输入：12*（3.6/3+4^2-1）#输出结果：194.4无定义运算：12*（3.6/（2^2-4）+1）#输出结果：表达式出错，除数为0，无意义错误输入：12+s#输出结果：eRRoR！二、概要设计拟采用两种类型的展分别对操作数和操作符进行操作。
数据结构实验报告表达式求值
数据结构实验报告题目：编制一个表达式求值的程序。
一．需求分析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. 设计者姓名、学号和班号: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的值改小。
数据结构表达式求值(可以求小数与多位数)
//栈顶压入一个数
S.top++; } char PopOPTR(SqStackOPTR &S,char &e){ --S.top; e=*S.top; return e; } float PopOPND(SqStackOPND &S,float &e){ --S.top; e=*S.top; return e; } Status GetTopOPTR(SqStackOPTR &S,char &e){ e=*(S.top-1); return e; } float GetTopOPND(SqStackOPND &S,float &e){ e=*(S.top-1); return e; } unsigned char Prior[7][7] = { '>','>','<','<','<','>','>', '>','>','<','<','<','>','>', '>','>','>','>','<','>','>', '>','>','>','>','<','>','>', // 算符间的优先关系 //取栈顶元素
数据结构课程设计-实验报告(一)表达式求值(计算器)
数据结构课程设计实验报告(一)表达式求值(计算器)数据结构课程设计实验报告起止时间：2015.12.28-2015.12.311、输入：tan452、输出：13、执行结果：：设计过程中遇到的问题及解决办法：问题：算数表达式以字符串输入，操作数和操作符的提取；解决办法：两两操作符之间如有数字将中间的数字提取强制转换成double型；参考文献：（在设计中参考的书籍、网站等资料）1. 朱振元，《数据结构——C++语言描述》，清华大学出版社，2008年，页码：2./doc/76dd2d95ec630b1c59eef8c75fbfc77da26997be.htm l /detail/gszhouyi/738777指导老师评议：成绩评定：指导教师签名：附件：（程序源代码）#include#include#include#include#define N 100#define pai 3.1415926typedef struct yxj{char operat;int rank;}yxj;typedef struct strchar data[N];}zs;void sjhs(void){char s[10],a[10];double y,x;printf("请输入(sin cos tan 角度制)表达式：\n"); scanf("%s",s);if(strstr(s,"sin")!=0){int i=0,j=0;while(s[i]!='\0'){if(s[i]>='0'&&s[i]s[j++]=s[i];i++;}s[j]='\0';x=atof(s);y=sin(x*pai/180);}else if(strstr(s,"cos")!=0){int i=0,j=0;while(s[i]!='\0'){if(s[i]>='0'&&s[i]s[j++]=s[i];i++;}s[j]='\0';x=atof(s);y=cos(x*pai/180);}else if(strstr(s,"tan")!=0){int i=0,j=0;while(s[i]!='\0'){if(s[i]>='0'&&s[i]s[j++]=s[i];i++;}s[j]='\0';x=atof(s);y=tan(x*pai/180);}else{printf("格式错误\n");return;}printf("%lf\n",y);printf("*****1、继续*****\n");printf("*****0、返回上一层*****\n"); scanf("%s",a);if(strcmp(a,"0")==0)return;else if(strcmp(a,"1")==0)sjhs();elseprintf("没有该选项\n");}void szys(yxj mark[]){yxj os[N];char a[10];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];ns[0]=0;printf("请输入算术（+ - * / ^）表达式（以= 结束）：\n");scanf("%s",data);if(strcmp(data,"+")==0||strcmp(data,"-")==0||strcmp(data,"*")==0||str cmp(data,"/")==0 ||strcmp(data,"^")==0||strcmp(data,"=")==0){printf("格式错误\n");return;}Len=strlen(data);numb[0]=0;for(i=0;izhan[i].data[0]='\0';for(i=0;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];jif(data[j]>='0'&&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;jif(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;switch(ch=os[--o].operat){case '+':{numb1=ns[--n];numb2=ns[--n];numb=numb1+numb2;ns[n++]=numb;break;}case '-':{numb1=ns[--n];numb2=ns[--n];numb=numb2-numb1;ns[n++]=numb;break;}case '*':{numb1=ns[--n];numb2=ns[--n];numb=numb2*numb1;ns[n++]=numb;break;}case '/':{numb1=ns[--n];numb2=ns[--n];if(numb1==0){printf("无效操作\n"); return;}else{numb=numb2/numb1;ns[n++]=numb;}break;}case '^':{numb1=ns[--n];numb2=ns[--n];numb=pow(numb2,numb1);ns[n++]=numb;break;}}}}}else if(data[i]>='0'&&data[i]else if(data[i]=='.'); else{printf("格式错误，请重新输入：\n");szys(mark);break;}}printf("%lf\n",ns[0]);printf("*****1、继续*****\n");printf("*****0、返回上一层*****\n");scanf("%s",&a);if(strcmp(a,"0")==0)return;else if(strcmp(a,"1")==0)szys(mark);elseprintf("没有该选项\n");}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[10];printf("*****1、四则运算计算器*****\n");printf("*****2、三角函数计算器*****\n"); printf("*****0、退出*****\n");scanf("%s",&i);if(strcmp(i,"0")==0)break;else if(strcmp(i,"1")==0)szys(mark);else if(strcmp(i,"2")==0)sjhs();elseprintf("没有该选项\n");}}-全文完-。
数据结构实验报告 表达式求值
(一) 需求分析1、输入的形式和输入值的范围：根据题目要求与提示，先选择你要使用的表达式形式（中缀用1，后缀用0），在输入一个中缀表达式，输入数的范围为int型，此时，程序将计算出表达式的结果。
2、输出的形式：当按照程序要求选择了1或0之后，再输入表达式；如果选择的是1，则程序将自动运算出表达式结果；如果之前选择的是0，则程序将现将中缀表达式转化为后缀表达式并计算出结果。
3、程序所能达到的功能：本程序能计算出含+、-、*、/、（、）等运算符的简单运算。
4、测试数据：输入一个表达式，如果你之前选择的是“中缀表达式”，那么输入5*(4-2)#,那么输出结果是10；如果之前选择的是“后缀表达式”，那么输入5*（4-2）#，那么他将先转换成后缀表达式5 4 2 - * #，再输出结果10。
如果输入表达式没有结束标示符#，如5*（4-2），那将不会输出任何结果，或出现错误结果。
(二) 概要设计为了实现上述操作，应以栈为存储结构。
1．基本操作：（1）. int GetTop(SqStack *s)初始条件：栈存在；操作结果：若栈为空，则返回s的栈顶元素；否则返回ERROR。
（2）.void Push(SqStack *s,int e)初始条件：栈存在；操作结果：插入e为新的栈顶元素。
（3）.int Pop(SqStack *s)初始条件：栈存在；操作结果：若栈不空，则删除之，并返回其值；否则返回REEOR。
（4）.void InitStack(SqStack *s)初始条件：栈存在；操作结果：置栈为空。
（5）.int Empty(SqStack *s)初始条件：栈存在；操作结果：判定s是否为空栈。
（6）.int Operate(int a,char theta, int b)初始条件：操作数a和b存在，且theta是+、-、*、/四则运算；操作结果：返回a与b间theta运算的结果。
（7）.int In(char s,char* TestOp)初始条件：s为待判断字符，TestOp为已知的算符集合；操作结果：s为算符集合中的元素则返回1，否则返回0.（8）.int ReturnOpOrd(char op,char* TestOp)初始条件：op为待确定运算符，TestOp为已知的算符集合；操作结果：确定运算符类型。
数据结构课程设计-表达式求值【完整版】
ＸＸXＸXX大学《数据结构》课程设计报告班级：学号：姓名：指导老师:目录一算术表达式求值一、需求分析二、程序得主要功能三、程序运行平台四、数据结构五、算法及时间复杂度六、测试用例七、程序源代码二感想体会与总结算术表达式求值一、需求分析一个算术表达式就是由操作数(oｐeranｄ）、运算符(operator）与界限符（deｌimiter)组成得。
假设操作数就是正整数，运算符只含加减乘除等四种运算符,界限符有左右括号与表达式起始、结束符“#”，如：＃(7+15）*（2３—２8/４）#。
引入表达式起始、结束符就是为了方便.编程利用“算符优先法”求算术表达式得值.二、程序得主要功能（1）从键盘读入一个合法得算术表达式，输出正确得结果。
(2）显示输入序列与栈得变化过程。
三、程序运行平台Ｖｉsｕaｌ C＋+6、0版本四、数据结构本程序得数据结构为栈。
（1）运算符栈部分：struct SqStaｃk ／/定义栈{char *base； //栈底指针ｃｈａr *toｐ; ／/栈顶指针inｔstacｋsiｚe； //栈得长度};inｔInitSｔack (SqＳｔack &ｓ) //建立一个空栈S{ｉf （!(s、ｂａse= (char ＊）ｍalloc(5０＊ｓizeof（chａr）)）)exｉt（0）；ｓ、ｔop=s、bａse;s、staｃksiｚｅ=５0；retuｒn OK；}ｃhar GeｔTop（SqStack s,char &e) /／运算符取栈顶元素｛iｆ (s、ｔop==s、ｂase) //栈为空得时候返回EＲROR｛ﻩ prｉntf(＂运算符栈为空！＼n")；ﻩ reｔurn ERＲＯR;｝elsee＝*（s、ｔoｐ-1); //栈不为空得时候用ｅ做返回值，返回S得栈顶元素，并返回OK returnＯＫ;｝ｉnt Push(SqStacｋ＆s，cｈａr ｅ） //运算符入栈｛if （s、tｏp—s、baｓe >= ｓ、ｓtacksｉzｅ）ﻩ{ｐriｎtf（＂运算符栈满!＼n"）;ﻩs、basｅ=（cｈaｒ*）reａlloｃ(s、bａｓe，(s、sｔackｓｉze+5)*ｓizeoｆ(cｈar））；//栈满得时候,追加5个存储空间ｉf(！s、basｅ)exｉt （OVERＦＬOW）；s、top=s、ｂａsｅ+s、ｓｔacｋsize;s、ｓtaｃksiｚｅ+=５;}ﻩ＊(s、ｔop）＋＋=e；／/把e入栈ﻩｒeturn OK;}ｉnｔ Pop(SqStaｃk &ｓ，char ＆ｅ） /／运算符出栈｛ｉｆ (s、toｐ==s、base) ／/栈为空栈得时候，返回ERＲOＲ｛ｐrintf（＂运算符栈为空!\n”）;ﻩ return ERROＲ;}else｛ﻩﻩe=＊-—ｓ、tｏp；/／栈不为空得时候用e做返回值，删除S得栈顶元素，并返回ＯK return OK；}}iｎt StackTｒaｖerse（ＳqStacｋ&ｓ)／/运算符栈得遍历｛ﻩchar ＊t；ﻩt=s、ｂａｓｅ；ﻩif (s、top＝=s、baｓe）｛ﻩ printｆ（”运算符栈为空！\ｎ”)； //栈为空栈得时候返回ＥＲRORｒeturn ERＲOＲ;}ｗhile（t！＝s、tｏp)｛ﻩﻩｐrｉｎｔf（" %c",＊t)； //栈不为空得时候依次取出栈内元素t++;ﻩ}ｒeturｎ EＲRＯR；｝（2）数字栈部分：strｕｃt SqSｔackn//定义数栈｛ｉnt *bａse; //栈底指针ｉnt＊tｏp； //栈顶指针ｉnｔ sｔacksｉze； //栈得长度｝;inｔIｎｉtStackｎ (SqSｔackn &s) //建立一个空栈Ｓ{s、base=（int＊）malｌoc（50*sｉzeof(int）);if(！ｓ、ｂase）eｘiｔ（OVEＲFLＯW）；//存储分配失败s、top=s、base；s、stacksizｅ=5０;reｔuｒn OK；｝ｉｎt GｅtToｐn(ＳqＳtａcｋn s,inｔ＆e) //数栈取栈顶元素{if（s、ｔop=＝s、base）{prinｔｆ(＂运算数栈为空!\ｎ＂);//栈为空得时候返回ERRORﻩ rｅturｎ ERROR;}eｌseﻩe＝＊（s、toｐ-1);／/栈不为空得时候，用e作返回值，返回S得栈顶元素，并返回OＫreturｎＯK；｝int Pｕshn（SｑStａckn ＆s，int ｅ) //数栈入栈｛if（s、tｏp—s、ｂasｅ＞＝s、stacksiｚe)｛ﻩﻩprｉｎｔf（"运算数栈满!\ｎ"）；／/栈满得时候,追加5个存储空间ﻩs、base=(int＊）realloc (s、baｓe,(s、stａcksize＋5)＊sｉzｅof（ｉnt));ｉf（!s、base) ｅxit (ＯＶERFLOW)；ﻩs、top=ｓ、bａsｅ＋ｓ、stacｋsize;//插入元素e为新得栈顶元素s、stacksｉｚe+=5；}*（s、top）++=e; /／栈顶指针变化returｎOK;}ｉｎt Popｎ(ＳｑSｔacｋn ＆s，iｎt &e)//数栈出栈｛ﻩif （s、top=＝ｓ、base）｛ﻩ pｒiｎtｆ（"运算符栈为空！\n＂);//栈为空栈得视时候，返回ERRＯＲﻩ retｕrn ERROR；ﻩ｝ｅlse｛ﻩﻩe=＊—-ｓ、tｏp；／/栈不空得时候，则删除S得栈顶元素,用e返回其值，并返回OK ﻩreturｎOK；｝}ｉnt StacｋＴraveｒsｅn（SqStackn &s)/／数栈遍历{ﻩiｎｔ＊t;ﻩｔ=s、basｅ ;ﻩif（s、top==s、basｅ）ﻩ｛pｒinｔf(＂运算数栈为空！\n”）；//栈为空栈得时候返回ERRORﻩ rｅｔｕrn ERＲＯＲ；ﻩ｝ﻩwｈile（t！=ｓ、ｔop)ﻩ{priｎtf(” ％d”，*ｔ); /／栈不为空得时候依次输出t＋＋;｝return ERRＯR；｝五、算法及时间复杂度１、算法:建立两个不同类型得空栈,先把一个‘＃’压入运算符栈。
数据结构表达式求值完整篇(含实验报告)
的是p*low），继续输入ch
总结:
我觉得写的好的地方在于定义了flag,low分别作为小数入栈和负号与减号区别的条
件。第一次写这么长的代码，还有就是将输入的字符再转到小数这段代码可以留着很有 用。开始考虑的大整数想麻烦了，直接用double难度降低了很多
4
【列岀你的测试结果，包括输入和岀。测试数据应该完整和严格，最好多于需求分析中所列。】
if(!s.base)
printf("\n运算符栈存储分配失败!\n");
s.top=s.base;
s.stacksize=MAXSIZE;
}
//
void OPND」n itStack(Sqstack_OPND &s)
{
s.base=new SElemType_OPND[MAXSIZE];
if(!s.base)
操作数和运算符分别入不同的栈charint进操作数栈先考虑了小于10的整数直接进栈重点是运算符的优先级这块函数的编写前面的都听简单的就是小数编写这块想了很久定义了low做判定符号的标志
数据结构表达式求值完整篇（含 实验报告）
1
(1)深入理解栈的特点及其描述方法
(2)能够在两种存储结构上实现栈抽象数据类型实现
&s,SElemType_OPND&e); //出栈
/*
#i nclude "common .h"
#include "Sqstack.h"
#in clude "other.h"
//
void OPTR_I ni tStack(Sqstack_OPTR &s)
{
数据结构表达式求值(中缀)实验报告
数据结构表达式求值（中缀）实验报告题目名称表达式求值学号姓名指导教师日期一1. 问题描述：在计算机中，算术表达式由常量、变量、运算符和括号组成。
由于不同的运算符具有不同的优先级，又要考虑括号，因此，算术表达式的求值不可能严格地从左到右进行，在程序设计时，借助栈实现。
2. 表达式求值这个程序，主要利用栈和数组，把运算的先后步骤进行分析并实现简单的运算，以字符列的形式从终端输入语法的正确的、不含变量的整数表达式。
利用已知的算符优先关系，实现对算术四则运算的求值，在求值中运用栈、运算栈、输入字符和主要操作的变化过程。
该程序相当于一个简单的计算机计算程序，只进行简单的加减乘除和带括号的四则运算。
1、基本思想（中缀表达式求值）要把一个表达式翻译成正确求值的一个机器指令序列，或者直接对表达式求值，首先要能够正确解释表达式，要了解算术四则运算的规则即：（1）先乘除后加减；（2）从左到右计算；（3）先括号内，后括号外。
下表定义的运算符之间的关系:b + - * / （） # a+ > > < < < > > _ > > < < < > > * > > > > < > > / > > > > < > > ( < < < < < = ) > > > > > > # < < < < < =为了实现运算符有限算法，在程序中使用了两个工作栈。
分别是：运算符栈OPTR,操作数栈OPND.基本思想：（1）首先置操作数栈为空栈，表达式起始符“#”为运算符栈的栈底元素；（2）依次读入表达式中每个字符，若是操作数则进OPND栈，若是运算符则和OPTR栈得栈顶运算符比较优先级后作相应操作。
数据结构实验报告-表达式求值与任务调度
数据结构与程序设计实验实验报告哈尔滨工程大学实验报告二printf("序号开始时间等待时间结束\n");que[0]=0;rear=1;T[0].start=0;i=0;t=0;j=1;while(i<n){t++;//时间移动i+=check(tdiff);//时间移动后检查是否有完成的任务，并且就算等待时间if(t>=T[j].t&&j<n){//假入在当前任务执行时间内有任务提交insert(j); //把任务插入到队列j++;qsort(que, rear, sizeof(que[0]), comp);//按时间长短排序}if(T[que[0]].start==-1)//给队列最前点赋起始值T[que[0]].start=t;}for(i=0;i<n;i++)//计算出所有等待时间sum+=T[i].wait;printf("平均等待时间为%.3lfs\n\n",sum/n);}四、界面设计1.表达式求值需要输入以’#’结尾的中缀表达式，以提示语句的方式给出。
输出注明是什么结果。
2.任务调度需要输入任务数，任务需要执行时间，（不同时需要任务提交时间），按平均等待时间最短为原则，输出出任务的执行顺序。
五、运行测试与分析1.表达式求值1).输入一个以’#’结尾的中缀表达式：2).输出计算结果，后缀表达式以及前缀表达式：3.任务调度：(1). 同时提交i).输入:ii).输出:(2). 不同时间提交i).输入:ii).输出:六、实验收获与思考1．熟练掌握栈的定义及使用。
2．了解表达式求值的转换算法。
设计前、后缀表达式求值算法。
3．设计操作数为多位实数，操作符为加、减、乘、除、求模的中缀表达式求值算法。
定义算数符号的优先级。
表达式求值数据结构实训报告
数据结构实训总结报告题目：表达式求值学生姓名：学生学号：专业班级：指导老师：目录1.课题分析 .....................................................................1．1需求分析..............................................................1. 2设计要求............................................................2.总体设计.......................................................................2．1主程序的流程.....................................................3.详细设计（步骤及代码实现） ...................................3. 1判断运算符优先级..............................................3. 2中缀表达式转后缀表达式..................................3. 3后缀表达式求值.................................................. 4．测试结果 .................................................................... 5．心得体会 .................................................................... 6．参考文献 ....................................................................1.课题分析1．1需求分析（1）栈“后进先出”的特点。
数据结构实验报告——四则运算表达式求值
数据结构实验报告——四则运算表达式求值实验五四则运算表达式求值一．问题描述：四则运算表达式求值，将四则运算表达式用中缀表达式，然后转换为后缀表达式，并计算结果。
二．基本要求：使用二叉树来实现。
三．实现提示：利用二叉树后序遍历来实现表达式的转换，同时可以使用实验二的结果来求解后缀表达式的值。
输入输出格式：输入：在字符界面上输入一个中缀表达式，回车表示结束。
输出：如果该中缀表达式正确，那么在字符界面上输出其后缀表达式，其中后缀表达式中两相邻操作数之间利用空格隔开；如果不正确，在字符界面上输出表达式错误提示。
测试实例：输入：21+23* （12-6 ）输出：21 23 12 6 -*+四．设计概要用二叉树表示表达式：若表达式为数或简单变量，则相应二叉树中仅有一个根结点，其数据域存放该表达式信息若表达式= （第一操作数）（运算符）（第二操作数），则相应的二叉树中以左子树表示第一操作数，右子树表示第二操作数，根结点的数据域存放运算符（若为一元算符，则左子树空）。
操作数本身又为表达式.后缀遍历二叉树码实现和静态检查上机调试及测试数据的调试五．源程序：#include#include#include#include#include#include#define STACK_INIT_SIZE 100#define DATA_SIZE 10#define STACKINCREMENT 10#define OK 1#define TRUE 1#define FALSE 0#define ERROR 0#define OVERFLOW -2using namespace std;typedef float SElemtype;typedef int Status;typedef char * TElemType;typedef struct BiTNode {TElemType data;int len; //data字符串中字符的个数struct BiTNode * lchild, * rchild;}BiTNode, *BiTree;typedef struct{SElemtype *base;SElemtype *top;int stacksize;} SqStack;Status IsDigital(char ch)if(ch>='0'&&ch<='9'){return 1; //是数字字母}return 0; //不是数字字母}int CrtNode(stack &PTR, char *c){BiTNode * T;int i=0;T = (BiTNode *)malloc(sizeof(BiTNode));T->data = (char *)malloc(DATA_SIZE*sizeof(char));while(IsDigital(c[i])){T->data [i] = c[i];i++;}T->len = i;T->lchild = T->rchild = NULL;PTR.push (T);return i;}void CrtSubTree(stack &PTR, char c){BiTNode * T;T = (BiTNode *)malloc(sizeof(BiTNode));T->data = (char *)malloc(DATA_SIZE*sizeof(char));T->data [0] = c;T->len = 1;T->rchild = PTR.top(); //先右子树，否则运算次序反了PTR.pop ();T->lchild = PTR.top();PTR.pop ();PTR.push (T);}char symbol[5][5]={{'>', '>', '<', '<', '>'}, //符号优先级{'>', '>', '<', '<', '>'},{'>', '>', '>', '>', '>'},{'>', '>', '>', '>', '>'},{'<', '<', '<', '<', '='}};int sym2num(char s) //返回符号对应优先级矩阵位置{switch(s){case '+': return 0; break;case '-': return 1; break;case '*': return 2; break;case '/': return 3; break;case '#': return 4; break;}}char Precede(char a, char b) //返回符号优先级{return(symbol[sym2num(a)][sym2num(b)]);void CrtExptree(BiTree &T, char exp[]){//根据字符串exp的内容构建表达式树Tstack PTR;//存放表达式树中的节点指针stack OPTR;//存放操作符char op;int i=0;OPTR.push ('#');op = OPTR.top();while( !((exp[i]=='#') && (OPTR.top()=='#')) ) //与{ if (IsDigital(exp[i])){//建立叶子节点并入栈PTRi+=CrtNode(PTR, &exp[i]);}else if (exp[i] == ' ')i++;else{switch (exp[i]){case '(': {OPTR.push (exp[i]);i++;break;}case ')': {op = OPTR.top (); OPTR.pop ();while(op!='('){CrtSubTree(PTR, op);op = OPTR.top (); OPTR.pop ();}//end whilei++;break;}default: //exp[i]是+ - * /while(! OPTR.empty ()){op = OPTR.top ();if (Precede(op, exp[i])=='>'){CrtSubTree(PTR, op);OPTR.pop ();}if(exp[i]!='#'){OPTR.push (exp[i]);i++;}break;}}//end switch}//end else}//end whileT = PTR.top();PTR.pop ();}void PostOrderTraverse(BiTree &T, char * exp ,int &count){//后序遍历表达式树T，获取树中每个结点的数据值生成逆波兰表达式exp //T是表达式树的根节点；字符串exp保存逆波兰表达式；count保存exp中字符的个数//后序遍历中，处理根结点时，依据T->len的值，把T->data中的字符依次添加到当前exp字符串的尾端//添加完T->data后，再添加一个空格字符，同时更新count计数器的值。
算术表达式求值数据结构实验报告
算法的正确性和效率分析
正确性
所有实现的数据结构都正确地实现了算术表达式求值的功能，没有出现计算错 误的情况。
效率
在处理大量数据时，使用堆栈（Stack）和队列（Queue）的数据结构表现最 佳。堆栈在处理后缀表达式时效率最高，而队列在处理中缀表达式时效率最高 。
数据结构优化的效果评估
使用哈希表（Hash Table）
展望未来，希望能够进一步研究算术 表达式求值算法的优化和改进，提高 计算效率和精度。
THANKS
感谢观看
05
列表（List）
数组（Array） 元组（Tuple） 集合（Set）
字典（ Dictiona…
由于列表在Python中是动 态数组，其性能在处理大 量数据时相对较差。在算 术表达式求值中，列表的 平均执行时间最长。
使用NumPy库的数组结构 ，其性能在处理大量数据 时优于列表。但在算术表 达式求值中，其性能仍然 不如其他数据结构。
03
了解如何使用栈数据结构实现括号匹配和回退机制 。
掌握数据结构在算术表达式求值中的应用
01 熟悉使用数组、链表等基本数据结构存储和操作 算术表达式。
02 掌握如何使用树形数据结构表示算术表达式，如 二叉树或表达式树。
03 了解动态规划在优化算术表达式求值中的运用。
提高编程能力和解决问题的能力
01
在处理重复元素时，使用哈希表可以显著提高数据结构的效率。在算术表达式求值中，哈希表的使用可以减少重 复计算和查找的时间。
预处理输入数据
对输入的算术表达式进行预处理，如括号消除、指数化等，也可以提高数据结构的效率。预处理可以减少运算的 复杂度和时间。
05
实验总结
本次实验的收获和体会
数据结构表达式求值实验报告
数据结构表达式求值实验报告一、实验目的本次实验的主要目的是通过实现表达式求值的程序，深入理解数据结构和算法在解决实际问题中的应用。
具体包括掌握栈这种数据结构的操作和使用，熟悉表达式的转换和计算过程，提高编程能力和问题解决能力。
二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。
三、实验原理表达式求值是程序设计中的一个常见问题，通常采用栈这种数据结构来实现。
表达式可以分为中缀表达式、后缀表达式和前缀表达式。
中缀表达式是我们日常使用的表达式形式，如“2 ＋3 4”，但直接对中缀表达式求值比较复杂。
而后缀表达式（如“2 3 4 ＋”）和前缀表达式（如“＋2 3 4”）求值相对简单。
因此，在实现表达式求值时，通常先将中缀表达式转换为后缀表达式，然后对后缀表达式进行求值。
转换过程中，使用两个栈，一个用于存储操作数，另一个用于存储运算符。
求值过程中，根据后缀表达式的特点，从左到右依次处理操作数和运算符，进行相应的计算。
四、实验步骤1、定义数据结构定义栈类，用于存储操作数和运算符。
定义一个结构体来表示操作数和运算符。
2、中缀表达式转后缀表达式从左到右扫描中缀表达式。
遇到操作数，直接输出。
遇到运算符，根据其优先级与栈顶运算符的优先级进行比较，决定入栈或出栈操作。
3、后缀表达式求值从左到右扫描后缀表达式。
遇到操作数，入栈。
遇到运算符，从栈中取出两个操作数进行计算，将结果入栈。
4、主函数输入中缀表达式。
调用转换函数和求值函数，输出计算结果。
五、实验代码｀｀｀cppinclude ＜iostream>include ＜stack>include ＜string>／／定义操作符的优先级int priority(char op) ｛if （op ＝＝＇＋＇｜｜ op ＝＝＇＇）return 1;if （op ＝＝＇＇｜｜ op ＝＝＇／＇）return 2;return 0;｝／／中缀表达式转后缀表达式std:：string infixToPostfix(std:：string infix) ｛std:：stack<char> opStack;std:：string postfix ＝＂＂；for （char c ： infix) ｛if （isdigit(c)）｛postfix ＋＝ c;｝ else if （c ＝＝＇（＇）｛｝ else if （c ＝＝＇）＇）｛while （！opStackempty(）＆＆ opStacktop(）！＝＇（＇）｛postfix ＋＝ opStacktop(）；opStackpop(）；｝opStackpop(）；／／弹出＇（＇｝ else ｛while （！opStackempty(）＆＆ priority(opStacktop(））＞＝priority(c)）｛postfix ＋＝ opStacktop(）；opStackpop(）；｝opStackpush(c)；｝｝while （！opStackempty(））｛postfix ＋＝ opStacktop(）；｝return postfix;｝／／后缀表达式求值int evaluatePostfix(std:：string postfix) ｛std:：stack<int> operandStack;for （char c ： postfix) ｛if （isdigit(c)）｛operandStackpush(c ＇0'）；｝ else ｛int operand2 ＝ operandStacktop(）；operandStackpop(）；int operand1 ＝ operandStacktop(）；operandStackpop(）；switch （c) ｛case ＇＋＇：operandStackpush(operand1 ＋ operand2)；break;case ＇＇：operandStackpush(operand1 operand2)；break;case ＇＇：operandStackpush(operand1 operand2)；break;case ＇／＇：operandStackpush(operand1 ／ operand2)；break;｝｝｝return operandStacktop(）；｝int main(）｛std:：string infixExpression;std:：cout ＜＜＂请输入中缀表达式: ＂；std:：cin ＞＞ infixExpression;std:：string postfixExpression ＝ infixToPostfix(infixExpression)；int result ＝ evaluatePostfix(postfixExpression)；std:：cout ＜＜＂表达式的计算结果为: ＂＜＜ result ＜＜ std:：endl;return 0;｝｀｀｀六、实验结果输入不同的中缀表达式，如“2 ＋3 4”“（ 2 ＋ 3 ）4”等，程序能够正确地将其转换为后缀表达式，并计算出结果。
数据结构表达式求值实验报告
竭诚为您提供优质文档/双击可除数据结构表达式求值实验报告篇一：数据结构实验二——算术表达式求值实验报告《数据结构与数据库》实验报告实验题目算术表达式求值学院：化学与材料科学学院专业班级：09级材料科学与工程系pb0920603姓学邮名：李维谷号：pb09206285箱：指导教师：贾伯琪实验时间：20XX年10月10日一、需要分析问题描述：表达式计算是实现程序设计语言的基本问题之一，它的实现是栈的应用的一个典型例子。
设计一个程序，演示通过将数学表达式字符串转化为后缀表达式，并通过后缀表达式结合栈的应用实现对算术表达式进行四则混合运算。
问题分析：在计算机中，算术表达式由常量、变量、运算符和括号组成。
由于不同的运算符具有不同的优先级，又要考虑括号，因此，算术表达式的求值不可能严格地从左到右进行。
因而在程序设计时，借助栈实现。
设置运算符栈（字符型）和运算数栈（浮点型）辅助分析算符优先关系。
在读入表达式的字符序列的同时完成运算符和运算数的识别处理，然后进行运算数的数值转换在进行四则运算。
在运算之后输出正确运算结果，输入表达式后演示在求值中运算数栈内的栈顶数据变化过程，最后得到运算结果。
算法规定：输入形式：一个(:数据结构表达式求值实验报告)算术表达式，由常量、变量、运算符和括号组成（以字符串形式输入）。
为使实验更完善，允许操作数为实数，操作符为（、）、.（表示小数点）、+、-、*、/、^（表示乘方），用#表示结束。
输出形式：演示表达式运算的中间结果和整个表达式的最终结果，以浮点型输出。
程序功能：对实数内的加减乘除乘方运算能正确的运算出结果，并能正确对错误输入和无定义的运算报错，能连续测试多组数据。
测试数据：正确输入：12*（3.6/3+4^2-1）#输出结果：194.4无定义运算：12*（3.6/（2^2-4）+1）#输出结果：表达式出错，除数为0，无意义错误输入：12+s#输出结果：eRRoR！二、概要设计拟采用两种类型的展分别对操作数和操作符进行操作。
数据结构实验报告-表达式求值与任务调度
数据结构与程序设计实验实验报告工程大学实验报告二i=0;t=0;j=1;while(i<n){t++;//时间移动i+=check(tdiff);//时间移动后检查是否有完成的任务，并且就算等待时间if(t>=T[j].t&&j<n){//假入在当前任务执行时间有任务提交insert(j); //把任务插入到队列j++;qsort(que, rear, sizeof(que[0]), comp);//按时间长短排序}if(T[que[0]].start==-1)//给队列最前点赋起始值T[que[0]].start=t;}for(i=0;i<n;i++)//计算出所有等待时间sum+=T[i].wait;printf("平均等待时间为%.3lfs\n\n",sum/n);}四、界面设计1.表达式求值需要输入以’#’结尾的中缀表达式，以提示语句的方式给出。
输出注明是什么结果。
2.任务调度需要输入任务数，任务需要执行时间，（不同时需要任务提交时间），按平均等待时间最短为原则，输出出任务的执行顺序。
五、运行测试与分析1.表达式求值1).输入一个以’#’结尾的中缀表达式：2).输出计算结果，后缀表达式以及前缀表达式：3.任务调度：(1). 同时提交i).输入:ii).输出:(2). 不同时间提交i).输入:ii).输出:六、实验收获与思考1．熟练掌握栈的定义及使用。
2．了解表达式求值的转换算法。
设计前、后缀表达式求值算法。
3．设计操作数为多位实数，操作符为加、减、乘、除、求模的中缀表达式求值算法。
定义算数符号的优先级。
数据结构课程设计表达式求值实验报告
数据结构课程设计表达式求值实验报告实验课程名称专业班级学生姓名学号指导教师20 至 20 年第学期第至周算术表示式求值演示一、概述数据结构课程设计，要求学生在数据结构的逻辑特性和物理表示、数据结构的选择和应用、算法的设计及其实现等方面，加深对课程基本内容的理解。
同时，在程序设计方法以及上机操作等基本技能和科学作风方面受到比较系统和严格的训练。
在这次的课程设计中我选择的题目是算术表示式求值演示。
表示式计算是实现程序设计语言的基本问题之一，也是栈的应用的一个典型例子。
设计一个程序，演示用算符优先法对算术表示式求值的过程。
深入了解栈和队列的特性，以便在解决实际问题中灵活运用它们，同时加深对这种结构的理解和认识。
二、系统分析1．以字符列的形式从终端输入语法正确的、不含变量的整数表示式。
利用已知的算符优先关系，实现对算术四则混合运算表示式的求值，并仿照教科书的例子在求值中运算符栈、运算数栈、输入字符和主要操作的变化过程。
2．一般来说，计算机解决一个具体问题时，需要经过几个步骤：首先要从具体问题抽象出一个适当的数学模型，然后设计一个解决此数学模型的算法，最后编出程序，进行测试，调试直至得到想要的答案。
对于算术表示式这个程序，主要利用栈，把运算的先后步骤进行分析并实现简单的运算！为实现算符优先算法，能够使用两个栈，一个用以寄存运算符，另一个用以寄存操作数和运算结果。
3．演示程序是以用户于计算机的对话方式执行，这需要一个模块来完成使用者与计算机语言的转化。
4．程序执行时的命令：本程序为了使用具体，采用菜单式的方式来完成程序的演示，几乎不用输入什么特殊的命令，只需按提示输入表示式即可。
（要注意输入时格式，否者可能会引起一些错误）5. 测试数据。
三、概要设计一个算术表示式中除了括号、界限符外，还包括运算数据和运算符。
由于运算符有优先级别之差，因此一个表示式的运算不可能总是从左至右的循序执行。
每次操作的数据或运算符都是最近输入的，这与栈的特性相吻合，故本课程设计借助栈来实现按运算符的优先级完成表示式的求值计算。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
&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);
//操作数栈初始化
char OPTR_GetTop(Sqstack_OPTR s);
//取运算符的栈顶元素
double OPND_GetTop(Sqstack_OPNDs);
if(!s.base)
printf("\n操作数栈存储分配失败!\n");
s.top=s.base;
s.stacksize=MAXSIZE;
}
//
char OPTR_GetTop(Sqstack_OPTR s)
{
if(s.top!=s.base)
return *(s.top-1);
return 0;
3
【⑴ 调试过程中遇到的问题是如何解决的以及对设计与实现中关键点的回顾讨论和分析；(2)算法的
时空分析(包括基本操作和其他算法的时间复杂度和空间复杂度的分析)和改进设想；(3)经验和体会等。】
1•栈的定义、初始化、出栈进栈、取栈顶元素等步骤不难就先把结构打好了
2.操作数和运算符分别入不同的栈
char->int进操作数栈先考虑了小于10的整数直接进栈，重点是运算符的优先级这块函数的编写
{ ~ ~
if(s.top == s.base)
prin tf("\n空栈!\n");
e=(*--s.top)-'0';
}
/*
#i nclude "common .h"
#include "Sqstack.h"
#in clude "other.h"
//
Sqstack_OPTR OPTR;
Sqstack_OPND OPND;
//
double OPND_GetTop(Sqstack_OPND s)
{
if( s.top!=s.base )
return ( *(s.top-1) )-'O';
return 0;
}
//
void OPTR_Push(Sqstack_OPTR &s,SEIemType_OPTR e){ ~ ~一if(s.top-s.base == s.stacksize)
表达式求值的算法优先算法
char Precede (SEIemType_OPTR top, char
ch); //比较OPTR勺栈顶元素和ch的优先级
double Operate (SEIemType_OPND a, SEIemType_OPTRheta, SElemType_OPND); //运算
prin tf("\n满栈!\n");
*s.top++=e; //先赋值后自加
}
//
void OPND_Push(Sqstack_OPND&s,SEIemType_OPND e){ ~ ~一if(s.top-s.base == s.stacksize)
prin tf("\n满栈!\n");
*s.top++=e+'0'; //先赋值后自加
}
//
void OPTR_Pop(Sqstack_OPTR&s,SEIemType_OPTR &e) {
if(s.top == s.base)
prin tf("\n空栈!\n");
e=*--s.top;
}
//
void OPND_Pop(Sqstack_OPND&s,SEIemType_OPND &e)
7
1+3-4*5/2+3.666#
-2.339
5
【给岀每部分的源代码（必须要有一定量的注释）o]
/* common.h */
#include "stdio.h"
#include "string.h"
#i nclude "ctype.h"
#in elude "math.h"
/*
double EvaluateExpressi on ( ); //算数
4
【列岀你的测试结果，包括输入和输岀。测试数据应该完整和严格，最好多于需求分析中所列。】
序号
输入
输出
说明
1
1--2#
3.000
减负数
2
-1-2#
-3.000
:两负数
3
-1--2#
1.000
4
3.66+4.34#
8.000
小数
5
2*2+4--3八2#
-1.000
r长串+乘方
6
3.66*2+3-4#
6.320
数据结构表达式求值完整篇（含 实验报告）
1
(1)深入理解栈的特点及其描述方法
(2)能够在两种存储结构上实现栈抽象数据类型实现
(3)掌握栈的几个典型应用算法，能灵活应用栈解决实际问题。
2
【定义所有抽象数据类型、自定义函数间的调用关系图，自定义函数的功能描述和流程图，以及主程
序的流程图。】
//
—
//
输出结
char ch;
{
s.base=new SEIemType_OPTR[MAXSIZE];
if(!s.base)
printf("\n运算符栈存储分配失败!\n");
s.top=s.base;
s.stacksize=MAXSIZE;
}
//
void OPND」n itStack(Sqstack_OPND &s)
{
s.base=new SElemType_OPND[MAXSIZE];