实用数据结构石油大学C语言表达式求值实验报告

合集下载

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

//存放运算数的栈的顺序存储表示
//存放运算符的栈的顺序存储表示
void InitStack(SqStack *S) //构造空栈（运算数栈） { S->base=(float*)malloc((STACK_INIT_SIZE)*sizeof(float)); S->top=S->base; S->stacksize=STACK_INIT_SIZE; } void initStack(sqStack *S) //构造空栈（运算符栈） { S->base=(char*)malloc((STACK_INIT_SIZE)*sizeof(char)); S->top=S->base; S->stacksize=STACK_INIT_SIZE; } float GetTop(SqStack *S) //用e返回栈顶元素（运
初始条件：a, b为整数，OP为运算符。操作结果：a与b进行运算，OP为二元运算符，返回其值。 }ADT Stack （2）符号之间的优先权关系比较 <：的优先权低于: =：的优先权等于 >：的优先权高于 + + * / ( ) # > > > > < > < > > > > < > < * < < > > < > < / < < > > < > < < ( < < < < < ) > > > > = > > = # > > > >
//用e返回栈顶元素

数据结构实习报告_设计一个演示用运算优先法对算数表达式求值过程的程序。

实习报告题目：设计一个演示用运算优先法对算数表达式求值过程的程序。

班级：姓名：学号：完成日期：一、需求分析1建立运算数栈SqStack1和运算符栈SqStack2辅助分析算符有限关系.2用户输入以“#”结尾的算数表达式，本程序需要用户自行输入表达式（运算符可以是加（+）；减（-）；乘（*）；除（/）；括号（（））），以字符形式读入，在读入的同时，完成运算符和运算数的识别处理，在识别出运算数的同时，要将其字符序列形式转换成整数形式。

3在程序的适当位置输出运算符栈、运算数栈、输入字符和主要操作的内容，即演示运算操作。

4测试数据见原题。

5程序执行的命令包括：（1）建立算数表达式；（2）得到运算表达式的值；（3）演示运算过程。

二、概要设计1.设定栈的抽象数据类型定义：ADT Stack{数据对象D＝{ ai | ai ∈charSet, i=1,2,...,n, n≥0 }数据关系：R1＝{ <ai-1, ai >| ai-1, ai∈D, i=2,...,n }（约定an 端为栈顶，a1 端为栈底）基本操作：InitStack（&S）操作结果：构造一个空栈S。

Gettop(S,&e)初始条件：栈S已存在。

操作结果：若栈S不空，则以e返回栈顶元素。

Push(&S,e)初始条件：栈 S 已存在。

操作结果：插入元素 e 为新的栈顶元素。

Pop(&S,&e)初始条件：栈 S 已存在且非空。

操作结果：删除 S 的栈顶元素，并用 e 返回其值。

}ADT Stack2.本程序包括三个模块（1）主程序模块：Void main( ){初始化；函数；}（2）栈模块——实现栈抽象数据类型（3）运算模块——实现运算并演示其过程模块各模块之间调用关系如下：主程序模块运算模块栈模块三、详细设计1、元素类型、结点类型typedef struct{int *base;int *top;int stacksize;}SqStack1; //操作数栈typedef struct{char *base;char *top;int stacksize;}SqStack2; //操作符栈2、栈类型typedef struct{char *base;char *top;int stacksize;}Stack; //栈类型栈的基本操作设置如下：void InitStack(Stack &S)//初始化，设S为空栈（S.top=NULL）Status GetTop(Stack S,ElemType e)//若栈S不空，则以e带回栈顶元素并返回TRUE，否则返回FALSE Status Push(Stack&S,ElemType e)//若分配空间成功，则在S的栈顶插入新的栈顶元素e，并返回TRUE，//否则返回FALSE其中部分操作的算法：Status Push(Stack &S,ElemType e){//若分配空间成功，则在S的栈顶插入新的栈顶元素e，并返回TRUE；//否则栈不变，并返回FALSEif(MakeNode(p,e)){P.next=S.top;S.top=p;S.size++;Return TRUE;}else return FALSE;}Status Pop(Stack &S,ElemType &e){//若栈不空，则删除S的栈顶元素并以e带回其值，且返回TRUE，//否则返回FALSE，且e无意义if(StackEmpty(S)) return FALSE;else{p=S.top;S.top=S.top->next;e=p->:data;S.size--;return TRUE;}}3、运算代码int Operate(int a,char theta,int b) //计算表达式值：主要是将大的表达式转化成小的表达式进行逐步求值{int c;if(theta=='+') c=a+b;else if(theta=='-') c=a-b;else if(theta=='*') c=a*b;else c=a/b;return c;}//Operateint result(SqStack1 *OPND,SqStack2 *OPTR) //求值{char a=0;char theta;int b,c,number=0;IntInitStack(OPND);CharInitStack(OPTR);CharPush(OPTR,'#');a=getchar();while(a!='#' || CharGetTop(OPTR)!='#'){printf("输入字符：%c ",a);if(!In(a)) //不是运算符则进栈{number=0;while(!In(a)){number = number*10 +(a-48); //处理多位整数z=10*x+ya = getchar();}IntPush(OPND,number);printf("主要操作：Push(OPND,%d) ",number);}elseswitch(Precede(a,CharGetTop(OPTR))){case '<':CharPush(OPTR,a);a=getchar();printf("主要操作：Push(OPTR,%c) ",a);break;case '=':CharPop(OPTR);a=getchar();printf("主要操作：Pop(OPTR,%c) ",a);break;case '>':theta=CharPop(OPTR);c=IntPop(OPND);b=IntPop(OPND);IntPush(OPND,Operate(b,theta,c));printf("主要操作：Operate(%d,%c,%d) ",b,theta,c);break;}printf("OPND栈：%d OPTR 栈：%c\n",IntGetTop(OPND),CharGetTop(OPTR));}printf("The result is %d.\n",IntGetTop(OPND)); //打印输出表达式值return OK;}4.主函数和其他函数的代码void main() //主函数，使用自定义函数完成功能{SqStack1 s1,*OPND;SqStack2 s2,*OPTR;OPND=&s1;OPTR=&s2;printf("Please enter an expression with a end of '#'.\n");printf("The Expression:");result(OPND,OPTR);}char Precede(char a,char b)//运算优先级判断{int i,j;char Table[8][8]={' ','+','-','*','/','(',')','#','+','>','>','<','<','<','>','>','-','>','>','<','<','<','>','>','*','>','>','>','>','<','>','>','/','>','>','>','>','<','>','>','(','<','<','<','<','<','=',' ',')','>','>','>','>',' ','>','>','#','<','<','<','<','<',' ','=',}; //优先级表格for(i=0;i<8;i++)if(Table[0][i]==a) //纵坐标寻找break;for(j=0;j<8;j++) //横坐标寻找if(Table[j][0]==b)break;return Table[j][i];}int In(char c) //判断c是否为操作符{if ( c=='(' || c=='+' || c=='-' || c == '*' || c=='/' || c==')' || c=='#' || c=='^')return 1; //如果是操作符返回1elsereturn 0; //不是，返回0}5．函数的调用关系图反映了演示程序的层次结构：mainresultInitStack Push GetTop In Precede Pop 四、调试分析算术表达式求值程序较为庞大，调试花费时间较多，主要是在for循环和while循环时容易出错，对于涉及的循环的操作开始和结束条件设置很关键。

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

数据结构表达式求值实验报告一、设计人员相关信息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的值改小。

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

一级标题靠左，加粗。

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

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

{
if (s.top-s.base >= s.stacksize)
{
printf("运算符栈满!\n");
s.base=(char*)realloc (s.base,(s.stacksize+5)*sizeof(char));
候
if(!s.base) exit (OVERFLOW);
s.top=s.base+s.stacksize;
{
e=*--s.top;
return OK;
}
}
int StackTraverse(SqStack&s) //运算符栈的遍历
{
char *t;
t=s.base ;
if (s.top==s.base)
{
printf("运算符栈为空!\n");〃栈为空栈的时候返回ERROR
return ERROR;
}
while(t!=s.top)
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;
}
else
加5个存储空间
if(!s.base) exit (OVERFLOW);
s.top=s.base+s.stacksize;
s.stacksize+=5;
}
*(s.top)++=e;//把e入栈

西南石油大学C语言实验三选择结构

实验报告三
一【实验目的】
1.学会正确使用逻辑运算符和逻辑表达式、关系运算符和关系表达式；
2.熟练掌握if语句和switch语句；
3.结合程序掌握一些简单的算法。

二【实验内容】
【实验1—课堂巩固】从键盘输入3个数，找出最大数并输出。

【实验2—课堂巩固】从键盘任意输入成绩在0～100的分数，要求用
if语句和switc h语句实现五级制的评定，评定条件如右图：
①输入一个负分数以及超过100分以上，不应该得到成绩，需
要给出错误提示；
②程序运行时，需要必要的提示语句。

【实验3-教材练习】从键盘输入一个年份，判断该年是否是闰年，要求有必要的提示语句。

（p15:实训2）闰年的条件：能被4整除但不能被100整除，或者能被400整除
【实验4－自我提高】编写计算器程序，要求如下：
①从屏幕获取两个变量的值和一个算术运算符（+、-、*、/、%），对这两个变量进行相应的算术运算，输出计算结果，对于其他运算符给出错误信息。

②用switch语句实现
三【实验过程】
【实验1】代码及运行结果：
【实验4】代码及运行结果：
四【实验小结】
通过这次实验我学会了很多，比如IF条件句的应用和SWITCH的应用。

各种问题只有在做的时候才能发现，所以我这次的收获很大。

学会了很多，我会继续努力，学好每一个要点！。

西安石油大学实验报告

min_row=i;
min_col=j;
}
}
printf("\n max value is m[%d][%d]=%d\n",max_row,max_col,max);
printf("\n min value is m[%d][%d]=%d\n",min_row,min_col,min);
}
2）保存源程序，文件名为C1.c
1）打开VisualC++6.0集成开发环境，编写程序代码如下：
#include <stdio.h>
void main()
{int m[3][4],i,j;
int max,min,max_row,min_row,max_col,min_col;
for (i=0;i<3;i++)
for (j=0;j<4;j++)
3）运行程序，输出结果如下：
2、练习[例5-14]，运行得出正确结果；之后，完成书283页实验四3.（要求：会编写）
找出三个字符串中最大一个
1）打开VisualC++6.0集成开发环境，编写程序代码如下：
#include<stdio.h>
void main()
{int i,m,k,j=0;
for(m=100;m<=200;m++)
2、练习[例5-14]，运行得出正确结果；之后，完成书283页实验四3.（要求：会编写）
3、完成书131页三3，运行得出正确结果；（要求：理解）
三、实验环境
VisualC++6.0，windows7系统。
四、实验步骤和结果

(完整版)数据结构与算法表达式求值报告

模块
• 各个模块的主要功能： *Push(SC *s,char c)：把字符压栈 *Push(SF *s,float f)：把数值压栈 *Pop(SC *s)：把字符退栈 *Pop(SF *s)：把数值退栈 Operate(a,theta,b)：根据theta对a和b进行'+' 、'-' 、'*' 、'/' 、'^'操作 In(Test,*TestOp)：若Test为运算符则返回true，否则返回false ReturnOpOrd(op,*TestOp)：若Test为运算符，则返回此运算符在数组中的下标 precede(Aop,Bop)：根据运算符优先级表返回Aop与Bop之间的优先级 EvaluateExpression(*MyExpression)：用算符优先法对算术表达式求值
c++;
后ቤተ መጻሕፍቲ ባይዱ表达式的计算机求值
• 与前缀表达式类似，只是顺序是从左至右
• 从左至右扫描表达式， • 遇到数字，将数字压入栈; • 遇到运算符，弹出栈顶的两个数，用运算符对它们做相应的计算
（次顶元素 operate with 栈顶元素），并将结果入栈； • 重复上述过程直到表达式最右端，最后运算得出的值即为表达式
SC *Push(SC *s,char c)
//SC类型的指针Push，返回p {
SC *p=(SC*)malloc(sizeof(SC));
p->c=c; p->next=s;
return p;
}
SF *Push(SF *s,float f) //SF类型的指针Push，返回p { SF *p=(SF*)malloc(sizeof(SF)); p->f=f; p->next=s; return p; }

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

数据结构(C语言版)实验报告

实验主要步骤
（ 1）数据从键盘读入；（ 2）输出要判断的字符串；（ 3）利用栈的基本操作对给定的字符串判断其是否是回文，若是则输出 “ No”。
“Yes”，否则输出
程序代码 :
实验结果：
心得体会：
实验 4
实验题目：二叉树操作设计和实现
实验目的：
掌握二叉树的定义、性质及存储方式，各种遍历算法。
//AdjList 是邻接表类型
typedef struct {
AdjList adjlist;
//邻接表
int n,e;
// 图中当前顶点数和边数
} ALGraph;
//图类型
//========= 建立图的邻接表 =======
void CreatALGraph(ALGraph *G)
{
int i,j,k;
for(i=0;i<G->n;i++)
//建立边表
{
scanf("%c",&a);
G->adjlist[i].vertex=a;
//读入顶点信息
G->adjlist[i].firstedge=NULL; }
//边表置为空表
printf("Input edges,Creat Adjacency List\n");
实验主要步骤：
设计一个有向图和一个无向图，任选一种存储结构，完成有向图和无向图的度优先遍历）和 BFS（广度优先遍历）的操作。
DFS（深
1．邻接矩阵作为存储结构
#include"stdio.h"
#include"stdlib.h"

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

2012级上机实习报告

课程名称：实用数据结构上机题目：表达式求值学生姓名：专业班级：指导教师实习时间2013年10月21日至11月09日成绩2013年11月11日一、需求分析（要实现的功能描述）1．问题描述设计并实现一个表达式的求值运算功能，如在屏幕上输入一个表达式“1+2*3-4/5”，程序能够计算其值。2．实现功能从键盘上输入一只包含有加减乘除和括号运算符的算术表达式，程序可实现计算步骤和结果的输出。3．测试数据1+2-3*4/51+2-1.5*2/（2+4）二、概要设计

程序包含五个模块，分别是字符串转换为实数、计算运算符的优先级、操作数栈运算、运算符栈运算和主函数。字符串转换为实数是将输入的字符串转化为算术表达式，在具体处理时，设置两个栈，运算符栈用于在处理过程中存放运算符，操作数栈用于处理过程中存放操作数。计算机从左到右依次读出表达式中各个符号，每读一个判断其为操作数还是运算符，若是操作数则将其压入操作数栈，并读下一个符号，若是运算符则利用计算运算符的优先级模块判断其优先级，若优先级大于栈顶元素的优先级则将其压入运算符栈并读下一个符号，若读出的符号优先级不大于栈顶元素则从操作数栈退两个元素，并从运算符栈退一个运算符，然后做相应计算，并将结果压入操作数栈。在这种情况下，当前读出符号下次需重新考虑。利用主函数中一个循环结构进行上述操作求出表达式的值。三、详细设计1．字符串转换为实数：doublenumber(char*s,int*k)2．计算运算符的优先级intfirst(charc)3．操作数栈运算

操作数栈运算之入栈voidpush1(double*s,ints_m,int*s_top,doublex)

操作数栈运算之退栈doublepop1(double*s,int*s_top)操作数栈运算之读栈顶元素doubletop1(double*s,int*s_top)

4．运算符栈运算运算符栈操作之入栈voidpush2(char*s,ints_m,int*s_top,charx)运算符栈操作之退栈charpop2(char*s,int*s_top)运算符栈操作之读栈顶元素chartop2(char*s,int*s_top)四、调试分析

1．程序在调式过程中出现的问题及解决方法刚开始只编写了一个Push和一个Pop函数，但因为在算法里既有运算符入出栈，又有运算数入出栈，运行下来总是出错。所以就编写了两个不同的Push和Pop函数，分别使用。2．心得体会在编写表达式求值的过程中，我加深了对栈的理解，对栈之一数据结构有了更深入的认识，在进行算法设计时，我也遇到了不少困难，出了一些错误，但在纠正错误的时候加深了我对程序设计的了解和认识，有许多意外的收获。在具体操作中这学期学到的知识得到了巩固，也发现了自己的不足之处，在以后的学习中要加以改正，同时也体会到了C语言的简洁高效。五、用户手册输入语法正确的、不含变量的数学表达式（运算符只能是'+'、'-'、'*'、'/'、'('、')'），回车即输出求完值的完整的表达式和计算步骤。六、测试结果根据已提供的测试数据得到什么样的结果（可以截屏）七、程序清单#include#include#include

doublenumber(char*s,int*k)//转换为实数

{doublex,y=1.0;intflag=1;charc;x=0.0;c=s[*k];//取当前符号

while((c>='0'&&c<='9')||c=='.')//为数字或小数点需转换

{*k=*k+1;//扫描指针进一

if(c>='0'&&c<='9'){if(flag==0)//转换小数点后数值并整数部分

{y=y*0.1;x=x+(c-48)*y;}else//转换整数部分数值

{x=10*x+(c-48);}}else//为小数点

{flag=0;}c=s[*k];//取当前符号

}return(x);//返回实数值

}

intfirst(charc)//计算优先级

{intk;switch(c){case'*':k=2;break;case'/':k=2;break;case'+':k=1;break;case'-':k=1;break;case'(':k=0;break;case')':k=0;break;case'\0':k=-1;break;}return(k);}

voidpush1(double*s,ints_m,int*s_top,doublex)//操作数栈入栈

{if(*s_top==s_m){printf("错误！\n");return;}*s_top=*s_top+1;s[*s_top-1]=x;return;}

doublepop1(double*s,int*s_top)//操作数栈退栈

{doubley;if(*s_top==0){printf("错误！\n");}y=s[*s_top-1];*s_top=*s_top-1;return(y);}doubletop1(double*s,int*s_top)//操作数栈读栈顶元素

{doubley;if(*s_top==0){printf("错误！\n");return0;}y=s[*s_top-1];return(y);}

voidpush2(char*s,ints_m,int*s_top,charx)//运算符栈入栈

{if(*s_top==s_m){printf("错误！\n");return;}*s_top=*s_top+1;s[*s_top-1]=x;return;}

charpop2(char*s,int*s_top)//运算符栈退栈

{chary;if(*s_top==0){printf("错误！\n");return'\0';}y=s[*s_top-1];*s_top=*s_top-1;return(y);}

chartop2(char*s,int*s_top)//运算符栈读栈顶元素

{chary;if(*s_top==0){printf("错误！\n");return'\0';}y=s[*s_top-1];return(y);}voidmain(){double*sv,x,y;char*sp,c,s[60];intsv_m,sv_top,sp_m,sp_top,flag=1,k;sv_m=50;sp_m=20;sv=malloc(sv_m*sizeof(double));//动态申请容量为m的存储空间

sv_top=0;//操作数栈栈空

sp=malloc(sp_m*sizeof(char));//动态申请容量为m的存储空间

sp_top=0;//运算符栈栈空

push2(sp,sp_m,&sp_top,'\0');//表达式结束符进运算符栈

printf("请输入要求的算式：\n");scanf("%s",s);printf("计算步骤：\n");k=0;c=s[k];while(flag){if(c>='0'&&c<='9'||c=='.'){push1(sv,sv_m,&sv_top,number(s,&k));//转换为实数进操作数栈

}elseif(c=='('||first(c)>first(top2(sp,&sp_top))){push2(sp,sp_m,&sp_top,c);//运算符进运算符栈

k=k+1;//扫描指针进一

}elseif((c=='\0')&&(top2(sp,&sp_top)=='\0')){flag=0;//置表达式处理结束标志

}elseif((c==')')&&(top2(sp,&sp_top)=='(')){pop2(sp,&sp_top);//退左括号

k=k+1;//扫描指针进一

}elseif(first(c)<=first(top2(sp,&sp_top))){y=pop1(sv,&sv_top);//取右操作数

x=pop1(sv,&sv_top);//取左操作数

c=pop2(sp,&sp_top);//取运算符

switch(c)//进行运算并输出运算步骤

{case'*':printf("%.2f*%.2f=",x,y);x=x*y;printf("%f\n",x);break;case'/':printf("%.2f/%.2f=",x,y);x=x/y;printf("%f\n",x);break;case'+':printf("%.2f+%.2f=",x,y);x=x+y;printf("%f\n",x);break;