数据结构实验2 四则运算
多项式的四则运算(数据结构)

数据结构07082018用链表实现多项式的四则运算——数据结构第二次上机作业班级07082姓名丁敏学号07082018上机时间2011年3月31日报告时间:2011年4月5日实验目的:熟练使用指针,熟悉链表及其操作;利用链表解决实际问题要求:能够实现任意项有理多项式的加、减、乘、除、求模以及幂运算多项式的除法注意除不尽的处理测试用例尽可能多,且说明用例的必要性用例必须包含一个自己系数为自己的学号摘要:多项式的四则运算问题是个很有趣的问题,它类似于有理数的四则运算,但又不仅仅于此.本篇课程论文重点研究了数据结构中多项式的四则运算问题。
本论文的程序是通过Microsoft Visual Studio 2010编译,来解决多项式的加、减、乘、除四则运算问题,从而达到了解数据结构的实用性及程序语言对于数学问题研究的重要性的目的。
正文:0需求分析:0.1问题描述编写程序来实现多项式的四则运算。
0.2基本要求⑴输入多项式的系数与指数,输入值为float型,输出值为float型;⑵能够完成多项式之间的四种计算方式(+、-、*、/)。
0.3函数说明typedef struct PolyNode:结构体变量,定义 int型指数和float 系数;PolyList CreatePolyList():创建多项式列表,返回头指针;DisplayPolyList(PolyList Poly):显示多项式;DestroyPolyList(PolyList L):释放链表所用存储空间;MergePoly(PolyList Poly):将多项式合并同类项;SortPoly(PolyList Poly):将多项式按升序排列;PolyList PolyAdd(PolyList PolyA , PolyList PolyB):多项式相加,返回和多项式链表头指针;PolyList PolySub(PolyList polyA , PolyList polyB):多项式相减,返回差多项式链表头指针;PolyList PolyMutiply(PolyList PolyA , PolyList PolyB):多项式相乘,结果由Poly c返回;PolyList PolyDivide(PolyList PolyA , PolyList PolyB):多项式相除,商和余数用系数为0的结点分开。
四则运算 数据结构

//用数据结构编写简单四则运算(+,-,*,/)//整体思路(可带多个括号,及小数)//建立一个单向链表//运算过程中运算符优先级# = ) + - * / (// 0 0 1 2 2 3 3 4// while(p->data && GetTop(OPTR))// { (p->data)// if(数字) 进栈OVS// else if(GetTop(OPTR)!='(' && p->data!=')')// {// if(GetTop(OPTR) 低于p->data 优先级)// 进栈OPTR// else// while(GetTop(OPTR) 高于p->data 优先级) // 运算// }// else 删去左右括号// }//字符转换为数字(用一个数组表示数字)//#include<stdio.h>#include<math.h>#include<conio.h>#include<io.h>#include<ctype.h>#include<stdlib.h>#include<string.h>#define N 5#define M 60typedef char ElemType;typedef struct node{ElemType data;struct node *next;}*LinkList, Node;typedef struct fnode{float data;struct fnode *next;}*FLinkList, FNode;LinkList BuildLink(char str[M]); //建立链表LinkList Push_char(LinkList L, ElemType data); //进入符号栈int IsEmpty(LinkList L); //栈是否为空ElemType GetTop(LinkList L); //取出符号栈顶栈不删除ElemType Pop_char(LinkList L, ElemType *x); //取出符号栈顶栈删除float Pop_float(FLinkList L, float *x); //取出数字栈顶栈删除int BracketMatch(char *e); //判断括号匹配float Execute(float m, char op, float n); //进行简单运算int Compare(char a); //比较运算符优先级float ExpEvaluation(LinkList L); //进行(可以括号,小数)的运算int Get_number(char ch); //字符转换为数字int GetNumber_1(int b[N], int i); //取整数部分float GetNumber_2(int b[N], int i); //取小数部分void Start(){LinkList L;float x;char str[M];printf("请输入运算式('='结束)\n");gets(str); //puts(str);BracketMatch(str);L = BuildLink(str);// BracketMatch(L); printf("ok2");x = ExpEvaluation(L);printf("上式运算结果为wei:");printf("%f\n", x);}LinkList BuildLink(char str[M]){LinkList L;Node *p,*s;int i;L = (LinkList)malloc(sizeof(Node));L->next=NULL;p = L;for(i=0; str[i]; i++){s = (Node*)malloc(sizeof(Node));s->data = str[i];p->next = s;p = s;}return L;}LinkList Push_char(LinkList L, ElemType data) {Node *temp;temp = (Node*)malloc(sizeof(Node));temp->data = data;temp->next = L->next;L->next = temp;return L;}FLinkList Push_float(FLinkList OVS, float data) {FNode *temp;temp = (FNode*)malloc(sizeof(FNode));temp->data = data;temp->next = OVS->next;OVS->next = temp;return OVS;}int IsEmpty(LinkList L){if(L->next == NULL)return 1;elsereturn 0;}ElemType GetTop(LinkList L){ElemType *x;Node *p;p = L->next;x = &p->data;*x = p->data;return *x;}ElemType Pop_char(LinkList L, ElemType *x){Node *p;p = L->next;*x = p->data;L->next = p->next;free(p);return *x;}float Pop_float(FLinkList L, float *x){FNode *p;p = L->next;*x = p->data;L->next = p->next;free(p);return *x;}int BracketMatch(char *e){int i,count=0,flag=1;char c;for(i=0;c=e[i];i++){if((c>='0'&&c<='9')||c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='.'||c=='#' || c=='=');else{system("cls");printf("表达式中含非法字符,请重新输入:");Start();}if(count==0&&c==')'){system("cls");printf("右括号多余,请重新输入:");Start();}else if(c=='(')count++;else if(c==')')count--;}if(count!=0){system("cls");printf("左括号多余,请重新输入:");Start();}return flag;}float Execute(float m, char op, float n){float x;switch(op){case'+': x = m + n; break;case'-': x = n - m; break;case'*': x = m * n; break;case'/':{if(m)x = n / m;else{system("cls");printf("式中除数为零!!请重新输入\n");Start();}break;}default: break;}return x;}int Compare(char a){if(a == '#' || a == '=') return 0;else if(a == ')') return 1;else if(a == '+' || a == '-') return 2;else if(a == '*' || a == '/') return 3;else if(a == '(') return 4;else{system("cls");printf("输入运算符错误!!请重新输入\n");Start();return -1;}}int Get_number(char ch){int x;switch(ch){case'0': x = 0; break;case'1': x = 1; break;case'2': x = 2; break;case'3': x = 3; break;case'4': x = 4; break;case'5': x = 5; break;case'6': x = 6; break;case'7': x = 7; break;case'8': x = 8; break;case'9': x = 9; break;default: break;}return x;}int GetNumber_1(int b[N], int i) {int j,k,t;int x=0;for(k=0; k<=i; k++){t = 1;for(j=1; j<i-k; j++)t = 10*t;x = x+b[k]*t;}return x;}float GetNumber_2(int b[N], int i) {int j,k;float x=0,t;for(k=0; k<=i; k++){t = (float)(0.1);for(j=0; j<i; j++)t = (float)(0.1*t);x = x+b[k]*t;}return x;}float ExpEvaluation(LinkList L) {LinkList OPTR;FLinkList OVS;int Dkey=0,key=1;int i,j;int x_1;float x,x_2,m,n;int b[N],a[N];Node *p;char op,ch;p = L->next;OPTR = (LinkList)malloc(sizeof(Node));OVS = (FLinkList)malloc(sizeof(FNode));OVS->next=NULL;Push_char(OPTR,'#');while(p->data!= '=' || GetTop(OPTR)!= '#'){if('0'<=p->data && p->data<='9'){i = 0;while('0'<=p->data && p->data<='9'){a[i] = Get_number(p->data);p = p->next;i++;}a[i] = 0;x_1 = GetNumber_1(a,i);if(p->data == '.'){j = 0;Dkey = 1;p = p->next;while('0'<=p->data && p->data<='9'){b[j] = Get_number(p->data);p = p->next;j++;}b[j] = 0;x_2 = GetNumber_2(b,j);}if(Dkey)Dkey = 0;elsex_2 = 0;x = x_1 + x_2;Push_float(OVS, x);}else{if(GetTop(OPTR)!='(' || p->data!=')'){if(GetTop(OPTR) == '(')Push_char(OPTR, p->data);else if((Compare(p->data) - Compare(GetTop(OPTR))) > 0)Push_char(OPTR, p->data);elseif((Compare(p->data) - Compare(GetTop(OPTR))) <= 0){key=0;Pop_char(OPTR, &op);Pop_float(OVS, &m);Pop_float(OVS, &n);x = Execute(m, op, n);Push_float(OVS, x);}}else if(OVS->next != NULL)Pop_char(OPTR,&ch);else{system("cls");printf("输入错误!! 括号中无数字请重新输入\n");Start();}if(key==1)p = p->next;if(key==0)key=1;}}Pop_float(OVS,&x);return x;}void main(){Start();}。
数据结构——四则运算

数据结构——四则运算要进⾏⼀个表达式的计算,⼀个关键的就是括号匹配问题,现在使⽤栈进⾏实现计算表达式的值,可以作为实现⼀个简单四则运算计算器核⼼部分。
根据栈的特性(先进后出),所以决定通过把输⼊的表达式转换为后缀表达式,通过后缀表达式进⾏计算。
实现⽅法:1.⾸先定义两个栈,⼀个⽤于存放操作符,⼀个⽤于存放操作数。
1 #include<stdio.h>2 #include<string>3 #include<conio.h>4#define MAXSIZE 1005 typedef float datatype;67 typedef struct8 {9 datatype a[MAXSIZE];10int top;11 }sequence_stack;1213 typedef struct14 {15char b[MAXSIZE];16int top;17 }SeqStack;2.需要两个数组,⼀个⽤于存放输⼊的中缀表达式,⼀个⽤于存放将中缀表达式转换后的后缀表达式。
将中缀表达式转换为后缀表达式的主要代码:1int operation(char op)//判断是否为操作符2 {3switch(op)4 {5case'+':6case'-':7case'*':8case'/':return1;9default:return0;10 }11 }12int priority(char op)//判断操作符的优先级13 {14switch(op)15 {16case'#':return -1;17case'(':return0;18case'+':19case'-':return1;20case'*':21case'/':return2;22default: return -1;23 }24 }25//将中缀表达式转换为后缀表达式26void postfix(char e[],char f[],SeqStack *s,sequence_stack *s1)27 {28int i=0,j=0;29int t;30 push_SeqStack(s,'#');31while(e[i]!='#')32 {33if((e[i]>='0'&&e[i]<='9')||e[i]=='.')34 f[j++]=e[i];35else if(e[i]=='(')36 {37 push_SeqStack(s,e[i]);38 }39else if(e[i]==')')40 {41 t=s->top-1;42while(s->b[t]!='(')43 {44 f[j++]=s->b[--s->top];45 t=s->top-1;46 }47 s->top--;48 }49else if(operation(e[i]))50 {51 f[j++]=' ';52while(priority(s->b[s->top-1])>=priority(e[i]))53 f[j++]=s->b[--s->top];54 push_SeqStack(s,e[i]);55 }56 i++;57 }58while (s->top)f[j++]=s->b[--s->top];59 {}60 evalpost(f,s1);61 }3.把存放后缀表达式的数组传递给计算后表达式的函数;计算后缀表达式的值主要代码:1float readnumber(char f[],int *i)//将数字字符串转变为数2 {3float x=0.0;4int k=0;5while(f[*i]>='0'&&f[*i]<='9')6 {7 x=x*10+(f[*i]-'0');8 (*i)++;9 }10if(f[*i]=='.')11 {12 (*i)++;13while(f[*i]>='0'&&f[*i]<='9')14 {15 x=x*10+(f[*i]-'0');16 (*i)++;17 k++;18 }19 }20while(k!=0)21 {22 x=x/10.0;23 k=k-1;24 }25return (x);26 }27void evalpost(char f[],sequence_stack *s)28 {29int i=0;30float x1,x2;31while(f[i]!='#')32 {33if(f[i]>='0'&&f[i]<='9')34 {35 push_sequence_stack(s,readnumber(f,&i));36 }37else if(f[i]==' ')38 i++;39else if(f[i]=='+')40 {41 x2=s->a[--s->top];42 x1=s->a[--s->top];43 push_sequence_stack(s,x1+x2);44 i++;45 }46else if(f[i]=='-')47 {48 x2=s->a[--s->top];49 x1=s->a[--s->top];50 push_sequence_stack(s,x1-x2);51 i++;52 }53else if(f[i]=='*')54 {55 x2=s->a[--s->top];56 x1=s->a[--s->top];57 push_sequence_stack(s,x1*x2);58 i++;59 }60else if(f[i]=='/')61 {62 x2=s->a[--s->top];63 x1=s->a[--s->top];64 push_sequence_stack(s,x1/x2);65 i++;66 }67 }68 }最后,只要调⽤计算后的结果将存放在操作数栈的第⼀个位置,并将结果传递给需要显⽰的地⽅(可以放到⾃⼰的程序中显⽰结果的地⽅),显⽰出结果就没问题了。
数据结构四则运算

具体思路:根据书上的栈的四则运算的应用里的提示,是用逆波兰(后缀表达式)算法进行运算。
我们正常的四则运算式的是中缀表达式,如:3+2*4-6/3*(4-2),但是这种语言机器无法识别,必须转换成后缀表达式,如:324*+63/42-*-,然后再用栈去进行操作运算。
首先,一个四则运算式包含操作符和运算符,所以要建立两个栈去分别存储他们,存储的时候,数字可以直存储,但是运算符因为要部分先出栈进行运算,所以此时就要考虑什么时候出栈,什么时候直接进栈,此时优先级矩阵就应运而生:在运算到+,-,*,/运算符时,则用栈顶元素与当前运算符进行优先级比较:●若对应的数组元素为-1,则当前运算符(运算符编码)进栈,调整pp 指向下一个字符。
●若对应的数组元素为1,则取运算符栈顶运算符和操作数栈顶操作数进行运算,参与运算的运算符和操作数出栈,运算结果进操作数栈。
实现为:OPND[topNd-2]=OPND[topNd-2] op OPBD[topNd-1];topNd--;topTr--;如果此时topTr-1还是比此时进栈的运算符优先级大的话,则执行循环上述过程。
●若当前字符是左括号(: 则直接进栈,pp 指向下一个字符●若当前字符是右括号):进行一下情况的讨论:若栈顶是左括号,则左括号出栈,pp 指向下一个字符若栈顶是运算符,则取运算符栈顶运算符和操作数栈顶操作数进行运算,参与运算的运算符和操作数出栈,运算结果进操作数栈。
实现为:OPND[topNd-2]=OPND[topNd-2] op OPBD[topNd-1];topNd--;topTr--;Op为topTr-1的运算符。
重复该操作,直到栈顶出现左括号“(”。
若栈顶是#,则左括号和右括号不配对,结束处理,返回出错标志(0)●若当前字符为#:依次从运算符栈取出运算符和从操作数栈取出操作数进行计算,直到运算符栈的栈顶为#为止。
此时就是把运算符栈里的运算符全部输出和操作数进行运算。
北理工数据结构实验报告2

《数据结构与算法设计》实验报告——实验二学院:自动化学院班级:____学号:__姓名:_____一、实验目的1、熟悉VC 环境,学习使用C 语言实现栈的存储结构。
2、通过编程、上机调试,进一步理解栈的基本概念。
3、锻炼动手编程,独立思考的能力。
二、实验内容实现简单计算器的功能,请按照四则运算加、减、乘、除、幂(^)和括号的优先关系和惯例,编写计算器程序。
要求支持运算符:+、-、*、/、%、()和=:① 从键盘输入一个完整的表达式,以回车作为表达式输入结束的标志;② 输入表达式中的数值均为大于等于零的整数,如果中间计算过程中出现小数也只取整进行计算。
例如,输入:4+2*5= 输出:14 输入:(4+2)*(2-10)= 输出:-48 三、程序设计 1、概要设计为实现上述程序功能,应使用两个栈,分别寄存操作数与运算符。
为此,需要栈的抽象数据结构。
(1)、栈的抽象数据类型定义为: ADT Stack{数据对象:D={|,1,2,,,0}i i a a ElemSet i n n ∈=≥数据关系:R1=11{,|,,2,,}i i i i a a a a D i n --<>∈=约定n a端为栈顶,1a端为栈底。
基本操作:InitStack(&S)操作结果:创建一个空栈S。
GetTop(S,&e)初始条件:栈S已存在且非空。
操作结果:用e返回S的栈顶元素。
Push(&S,e)初始条件:栈S已存在。
操作结果:插入元素e为新的栈顶元素。
Pop(&S,&e)初始条件:栈S已存在且非空。
操作结果:删除S的栈顶元素,并用e返回其值。
In(m,a[])操作结果:若m是运算符,返回TRUE。
Precede(m, n)初始条件:m,n为运算符。
操作结果:若m优先级大于n,返回>,反之亦然。
Operation(a, theta,b)初始条件:a,b为整数,theta为运算符。
数据结构综合实训长整数四则运算

4
长整数四则运算实现
长整数四则运算实现
加法
对于加法,我们需要从低位到高位依次相加。如果结果大于等于10,我们需要进位。我们 可以使用链表或数组来实现这个算法
链表加法示例代码(Python)
THANK YOU
2
数据结构选择
数据结构选择
链表
链表是一种动态数据结构,可以根据需要随时增加或减少节点。链表中的每个节点包含两 部分:数据和指向下一个节点的指针。使用链表可以方便地实现长整数的每一位的存储和 操作
数据结构选择
数组
数组是一种静态数据 结构,其大小在创建 时确定,不能更改。 对于长整数,我们可 以使用数组来表示每 一位数字,从而实现 大数的存储和运算
20XX
数据结构综合实训 -长整数四则运算
时 间:20XX-XX-XX
-
1 2 3 4
1
引言
引言
在计算机科学中,长整数四则运算是一 个经典问题
由于计算机的整数类型通常有固定的范 围,在进行大数运算时,必须采用特殊 的数据结构和技术来处理
本实训将介绍如何使用链表和数组来实 现长整数的表示和四则运算
数据结构选择
3
长整数表示
长整数表示
链表表示法
我们可以将长整数表示为一个链表,其中 每个节点存储一个数字(0-9)。例如,数 字123可以表示为1->2->3。链表的头部表 示整数的低位,尾部表示高位
长整数表示
数组表示串中的每个字符存储在数 组的一个元素中。例如,数字123可以表示为array [ 0]=1, array [ 1]=2, array [ 2]=3
数据结构课程设计四则运算表达式求值(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 }。
北京理工大学数据结构与算法设计实验二

《数据结构与算法设计》实验报告——实验二学院:自动化学院班级:06111001学号:**********姓名:宝竞宇一、实验目的掌握栈的建立,输入,删除,出栈等基本操作。
应用栈解决实际问题。
二、实验内容实现简单计算器的功能,请按照四则运算加、减、乘、除、幂(^)和括号的优先关系和惯例,编写计算器程序。
要求支持运算符:+、-、*、/、%、()和=:①从键盘输入一个完整的表达式,以回车作为表达式输入结束的标志;②输入表达式中的数值均为大于等于零的整数,如果中间计算过程中出现小数也只取整进行计算。
例如,输入:4+2*5= 输出:14输入:(4+2)*(2-10)= 输出:-48三、程序设计1、概要设计抽象数据类型定义:两个栈结构,分别用来储存数据和计算符号宏定义:函数“成功”,“失败的返回值”在主程序程序中先依次输入各表达式,存入相应各栈,然后,调用“判断函数”来判断计算符的优先次序,然后再利用计算函数来计算,表达式值。
其中还有,取栈顶元素函数,存入栈函数。
2、详细设计数据类型实现:struct t{ char dat[200];int top;}prt;入栈函数:存入数组,栈顶指针上移void pushd(long int a){ prd.dat[prd.top++]=a;}出栈:取出对应值,栈顶指针下移long int popd( ){ return prd.dat[--prd.top];}比较优先级:建立数组,比较返回大于小于号。
计算函数:以字符型输入,运算符号,用switch来分支计算判断,返回计算数值long int operation ( long int x, long int y, char a){ s witch(a){ case '+': return x+y;case '-': return x-y;case '*': return x*y;case '/': if ( y )return x/y;else{ printf("Divide 0.\n");return 0;}case '%': return (long int) fmod(x,y);case '^': if (y>=0 ) return (long int) pow(x,y);else return (0);default: printf("Error No. 3\n");return 0;}}主程序:在主程序内,以字符串的形式输入表达式,然后分别调用函数存入各相应栈,然后用数组判断,比较运算符的优先顺序。
数据结构有理数四则运算

while(a%b!=0){ p=b; b=a%b; a=p; } comdiv=b; z->up=z->up/comdiv; z->dn=z->dn/comdiv; } //输出 out(InitRational* z){ if(z->up==0) printf("%d\n",z->up); else printf("%d/%d\n",z->up,z->dn); }
数据结构实验报告 题目:
学 专
院 业
计算机学院 计算机科学与技术 2011 级 班 3111005746 莫兴朝 刘添添(谭台哲)
年级班别 学 号
学生姓名 指导教师
成
绩 ____________________
2013 年 6 月 预习报告
1. 题目 有理数的四则运算 2.存储结构定义 (1)动态分配的顺序存储结构 typedef int Status; typedef int ElemType; typedef ElemType * Rational; (2)线性表的链式存储结构 #include<stdio.h> typedef struct InitRational{ int up; int dn; }InitRational;
Status InitRational(Rational &R, ElemType frac, ElemType deno){ //初始化有理数 R=(ElemType *) malloc(2*sizeof(ElemType)); if(!R) exit(OVERFLOW); R[0]=frac;R[1]=deno; return OK; }//InitRational Status DestroyRational(Rational &R){ //销毁有理数 free(R); R=NULL; return OK; }//DestroyRational int gcd(ElemType m, ElemType n){ //求最大公因数 int r; if(m<0)m=-m; if(n<0)n=-n; r=m%n; //辗转相除法:除数变被除数,余数变除数,商为 0 停
数据结构c语言版算术四则混合运算实验报告

数据结构c语言版算术四则混合运算实验报告一、引言在计算机科学领域,算术四则运算是最基本的运算之一。
本实验旨在通过使用C语言编写程序,实现算术四则运算的混合运算功能。
通过该实验,我们可以提高对数据结构的理解,并掌握在C语言中实现算术四则混合运算的方法。
二、实验目的1. 理解算术四则运算的基本原理;2. 掌握数据结构在算术四则运算中的应用;3. 使用C语言编写程序,实现算术四则混合运算功能。
三、实验方法1. 首先,我们需要定义并实现一个栈数据结构,用于存储运算符和操作数;2. 然后,通过读取用户输入的表达式,将其中的运算符和操作数依次入栈;3. 在入栈的过程中,我们需要判断运算符的优先级,以确保正确的运算顺序;4. 最后,通过出栈的方式,按照正确的运算顺序进行运算,并输出结果。
四、实验步骤1. 定义并实现栈数据结构,包括入栈、出栈等基本操作;2. 读取用户输入的表达式,并将其中的运算符和操作数依次入栈;3. 根据运算符的优先级,确定出栈的顺序,并进行相应的运算;4. 将运算结果入栈,继续进行下一轮的运算,直到表达式中的所有运算符和操作数都被处理完毕;5. 最后,将最终的运算结果出栈,并输出。
五、实验结果通过本实验,我们成功实现了算术四则混合运算的功能。
经过多组测试,程序能够正确处理各种复杂的运算表达式,并给出正确的结果。
六、实验总结通过本次实验,我们进一步加深了对数据结构的理解,并成功将其应用于算术四则混合运算中。
我们掌握了C语言中实现算术四则混合运算的方法,并通过编写程序实现了该功能。
通过本次实验,我们不仅提高了对数据结构的应用能力,还提升了编程能力和问题解决能力。
在今后的学习和工作中,我们将继续深入研究数据结构和算法,不断提升自己的编程技术,为解决实际问题提供更好的解决方案。
七、致谢感谢指导老师对本实验的支持和指导,感谢实验室的同学们在实验过程中给予的帮助和建议。
本次实验的顺利完成离不开你们的支持与帮助。
数据结构长整数四则运算

数据结构长整数四则运算实习 1 1.4 长整数四则运算实习报告题目:设计一个实现任意长的整数进行加法运算的演示程序。
一、需求分析1. 本演示程序中,利用双向循环链表实现长整数的存储,每个结点含一个整型变量任何整型变量的范围是 - ( 215-1 )—( 215-1 )。
在每个结点中仅存十进制数的 4位,即不超过 9999 的非负整数,整个链表表示为万进制数。
输入和输出形式按中国对于长整数的习惯,每四位一组,组间用逗号隔开。
2. 演示程序以用户和计算机的对话方式执行,即在计算机终端上显示“提示信息”之后,由用户在键盘上输入演示程序中规定的运算命令;相应的输入数据(滤去输入数据中的非法字符)和运算结果显示在其后。
3. 程序执行的命令包括:(1)构造链表;( 2)输入数据;( 3)数据处理;( 4)结束4. 测试数据 1) 0; 0;应输出 0。
2) -2345,6789 ; -7654,3211 ;应输出 -1,0000,0000.3) -9999,9999 ; 1,0000,0000,0000 ;应输出 9999,0000,00014) 1,0001,0001 ;-1,0001,0001 ;应输出 0。
5)1,0001,0001 ;-1,0001,0000 ;应输出 1.; -9999,9999,9999 ;应输出 -1,9999,9999,9998struct LinkNode //定义结构体 LinkNode{int data; // LinkNode *next; //LinkNode *pre; // };class LinkList // 定义类 LinkList7)1,0000,9999,9999 ; 1;应输出 1,0001,0000,0000概要设计6)-9999,9999,9999记录每个节点的整数(小于 10000)记录下一个节点的地址记录前一个节点的地址private:Lin kNode *head0,*head1; //headO ,headl分别记录两个整数链表的头指针Lin kNode*currptr;Lin kNode *result; //result 记录结果链表的头指针public:Lin kList(); // ~Li nkList(); // void Creat(stri ng a); // void Add(); // void Display(); // void addtwo(); //构造函数,初始化链表析构函数,释放空间引入字符串,创立两个链表,分别表示两个整数实现两个整数相加显示结果节点多的作为被加数,少的作为加数,实现整大的加小的//数绝对值};void mai n() //主函数do{} while(Yes_No=='y'||Yes_No=='Y'); //Yes_No 不等于'Y'或'y'时,程序退出三、详细设计#include#in clude#in cludeusing n amespace std;struct Lin kNode{int data; //Li nkNode *n ext; // 记录每个节点的整数(小于10000)记录下一个节点的地址Lin kNode*pre;// 记录前一个节点的地址Lin kNode *head0,*head1; //headO,head1分别记录两个整数链表的头指针}; class Lin kList private:Lin kNode *currptr;Lin kNode *result; //result 记录结果链表的头指针public: Lin kList(); // ~Li nkList(); // void Creat(stri ng a); // void Add(); // void Display 。
数据结构 复数的四则运算

《数据结构》实验报告题目:复数的四则运算专业:计算1191学号: **********姓名:***2012-2013学年第一学期一实验内容实验1 抽象数据类型复数的实现二实验目的1.设计一个可以进行复数运算的演示程序三需求分析实现下列六种基本预算:1)由输入的实部虚部生成一个复数;2)两个复数求和;3)两个复数求差;4)两个复数求积;5)从已知复数中分离出实部;6)从已知复数中分离出虚部;四详细设计源程序:# include"stdio.h"# include"stdlib.h"struct complex{float real;float imaginary;};void InitComplex(complex &c,float r1,float r2){c.real=r1;c.imaginary=r2;}void AddComplex(complex &c,complex c1,complex c2){c.real=c1.real+c2.real;c.imaginary=c1.imaginary+c2.imaginary;}void SubComplex(complex &c,complex c1,complex c2){c.real=c1.real-c2.real;c.imaginary=c1.imaginary-c2.imaginary;}void MulComplex(complex &c,complex c1,complex c2){c.real=(c1.real*c2.real)-(c1.imaginary*c2.imaginary);c.imaginary=(c1.real*c2.imaginary)+(c2.real*c1.imaginary);}void RealComplex(complex c,float &r){r=c.real;}void ImaComplex(complex c,float &r){r=c.imaginary;}void main(){complex c,c1,c2;float r,r1,r2,r11,r12,r21,r22;int node;printf("请?输º?入¨?序¨°号?:\n");printf("1:构1造¨¬复¡ä数ºy;2:复¡ä数ºy求¨®和¨ª;3:复¡ä数ºy求¨®差?\n");printf("4:复¡ä数ºy求¨®积y;5:返¤¦Ì回?实º¦Ì部?;6:返¤¦Ì回?虚¨¦部?\n");scanf("%d",&node);while(node!=0){switch(node){case1: printf("请?输º?入¨?复¡ä数ºy:êo实º¦Ì部?,ê?虚¨¦部?\n"); scanf("%f,%f",&r1,&r2);InitComplex(c,r1,r2);printf("构1造¨¬复¡ä数ºy:c=%f+i%f\n",c.real,c.imaginary);break;case2: printf("请?输º?入¨?复¡ä数ºyc1的Ì?:êo实º¦Ì部?,ê?虚¨¦部?\n"); scanf("%f,%f",&r11,&r12);InitComplex(c1,r11,r12);printf("请?输º?入¨?复¡ä数ºyc2的Ì?:êo实º¦Ì部?,ê?虚¨¦部?\n");scanf("%f,%f",&r21,&r22);InitComplex(c2,r21,r22);AddComplex(c,c1,c2);printf("结¨¢果?为a:c=%f+i%f\n",c.real,c.imaginary);break;case3: printf("请?输º?入¨?复¡ä数ºyc1的Ì?:êo实º¦Ì部?,ê?虚¨¦部?\n"); scanf("%f,%f",&r11,&r12);InitComplex(c1,r11,r12);printf("请?输º?入¨?复¡ä数ºyc2的Ì?:êo实º¦Ì部?,ê?虚¨¦部?\n");scanf("%f,%f",&r21,&r22);InitComplex(c2,r21,r22);SubComplex(c,c1,c2);printf("结¨¢果?为a:c=%f+i%f\n",c.real,c.imaginary);break;case4: printf("请?输º?入¨?复¡ä数ºyc1的Ì?:êo实º¦Ì部?,ê?虚¨¦部?\n"); scanf("%f,%f",&r11,&r12);InitComplex(c1,r11,r12);printf("请?输º?入¨?复¡ä数ºyc2的Ì?:êo实º¦Ì部?,ê?虚¨¦部?\n");scanf("%f,%f",&r21,&r22);InitComplex(c2,r21,r22);MulComplex(c,c1,c2);printf("结¨¢果?为a:c=%f+i%f\n",c.real,c.imaginary);break;case5: printf("请?输º?入¨?复¡ä数ºyc的Ì?:êo实º¦Ì部?,ê?虚¨¦部?\n"); scanf("%f,%f",&r1,&r2);InitComplex(c,r1,r2);RealComplex(c,r);printf("结¨¢果?为a:%f\n",r);break;case 6: printf("请?输º?入¨?复¡ä数ºyc的Ì?:êo实º¦Ì部?,ê?虚¨¦部?\n");scanf("%f,%f",&r1,&r2);InitComplex(c,r1,r2);ImaComplex(c,r);printf("结¨¢果?为a:%f\n",r);break;default:printf("结¨¢束º?");}}}加法程序展示:减法程序展示:求积程序展示:分离出实部;分离出虚部:步骤五:实验总结1.通过本次实验,基本掌握抽象数据类型的定义方法及要求;2.基本掌握C语言程序设计的规范操作流程;3.编程过程中有些地方考虑不全面,程序不够健壮,;。
湖南大学数据结构四则运算表达式报告

实验报告部分HUNAN UNIVERSITY 课程实习报告题目:约瑟夫问题学生姓名付勇学生学号201226010603 专业班级计算机科学二班指导老师李晓红一、需求分析1.本程序要求首先输入一组数据进行四则运算,输入的数据是按照中缀表达式的结构输入的,完成初始化后,把中缀表达式转化为后缀表达式(逆波兰表达式)输出,同时输出计算结果。
2.程序的功能将输入的中缀表达式转化为后缀表达式输出,同时输出计算结果;3.程序的输出就是转化后的后缀表达式以及计算的结果,输出结果间用空格隔开;4.测试数据:输入:21+23*(12-6)//正常的中缀表达式结构输入有数据,有+ - * / %()^21+(12-6)*2325^12*1+225 7 7//数据输入中可以留空格,两个数据中间必须是符合四则运算的数据(+-*/()^)输出:接上后缀表达式为:21 23 12 6 - * + //输出结果间用一个空格隔开计算结果为:159后缀表达式为:21 12 6 - 23 * +计算结果为:159输入非法,程序结束!输入非法,程序结束!。
二、概要设计抽象数据类型中缀表达式的存入和读取是核心问题,计算只要用到两个临时的栈一个存操作数,一个存运算符。
利用二叉树,根节点存操作符,其他节点存操作数,利用二叉树的遍历可以方便的存入和读出操作数和运算符。
(后序遍历实现后缀表达式)二叉树的ADT与节点的ADT分开定义ADT BinNode数据对象:数和字符数据关系:无基本操作:int val() //返回结点的数值Void setVal(const Elem&)//设置节点的值inline BinNode* left()const //获取左结点inline BinNode* right()const //获取右结点void setLeft(Node* it) //设置左结点void setRight(Node* it) //设置右结点Bool isLeaf()//是叶子节点吗?二叉树ADT BinTree数据对象:D={d I∈BinNode |i=0,1,2….}数据关系:若D为空集,则称为空树。
数据结构实验报告——四则运算表达式求值

数据结构实验报告——四则运算表达式求值实验五四则运算表达式求值一.问题描述:四则运算表达式求值,将四则运算表达式用中缀表达式,然后转换为后缀表达式,并计算结果。
二.基本要求:使用二叉树来实现。
三.实现提示:利用二叉树后序遍历来实现表达式的转换,同时可以使用实验二的结果来求解后缀表达式的值。
输入输出格式:输入:在字符界面上输入一个中缀表达式,回车表示结束。
输出:如果该中缀表达式正确,那么在字符界面上输出其后缀表达式,其中后缀表达式中两相邻操作数之间利用空格隔开;如果不正确,在字符界面上输出表达式错误提示。
测试实例:输入: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计数器的值。
2长整数四则运算 数据结构课程设计[精品]
![2长整数四则运算 数据结构课程设计[精品]](https://img.taocdn.com/s3/m/dbd42a405f0e7cd185253619.png)
2长整数四则运算数据结构课程设计[精品] [实验名称]长整数四则运算[需求分析]设计一个实现任意长的整数进行减法运算的演示程序,要求完成长整数的加减运算,乘除运算可选做。
在这里长整数没有范围限制,可任意长。
运算后的进位、借位等都要进行正确处理,可实现动态的输入,实时的输出。
测试数据:0、0; 输出“0”-7654,3211; 输出“1,0000,0000” 2345,6789、1,0000,0000,0000、9999,9999; 输出“9999,0000,0001”1,0001,0001、;1,0001,0001; 输出“0”自选数据:1,2345,6789; 9,8765,4321; 输出“11,1111,1110”[概要设计]数据结构利用双向循环链表来实现对长整数的存储。
每个节点只存储四位十进制数字,即不超过9999的非负整数。
双向链表有头指针,它的data值存储长整数的符号,1为正,-1为负,0代表长整数为0;它的over值存储除头节点外节点的个数。
其他节点的data值存储四位整数,over存储该四位整数溢出0~~9999范围的情况,一般over>0表示四位数超出9999,over<0表示四位数小于0。
选择该数据结构来完成长整数的加减运算是因为要对长整数进行运算,需要对长整数进行存储,所以选择用链表对长整数存储,又由于存储的顺序是从左到右,而运算的顺序则是从右到左,这样位了操作方便选择循环链表,在运算过程中有进位和借位的操作,所以最终选择双向循环链表的数据结构。
[详细设计]typedef struct DoubleNode //定义链表元素void InitNode(DLNode **head) //初始化链表int InsertNode(DLNode *head,int n,DataType x) //向链表第N个位置插入元素Xint digit(int n) //判断整数N有几位void PrintNode(DLNode *head) //打印链表void DestroyNode(DLNode **head)//销毁链表void add(DLNode *h1,DLNode *h2) //两数相加void jian(DLNode *h1,DLNode *h2) //两数相减int main() //入口函数[调试分析]调试过程中的困难:在数据的运算中,应为是根据数的大小来选择运算的,所以过程相对比较繁琐。
数据结构实验二——算术表达式求值实验报告

《数据结构与数据库》实验报告实验题目算术表达式求值学院:化学与材料科学学院专业班级:09级材料科学与工程系PB0920603姓名:李维谷学号:PB09206285邮箱:liwg@指导教师:贾伯琪实验时间:2010年10月10日一、需要分析问题描述:表达式计算是实现程序设计语言的基本问题之一,它的实现是栈的应用的一个典型例子。
设计一个程序,演示通过将数学表达式字符串转化为后缀表达式,并通过后缀表达式结合栈的应用实现对算术表达式进行四则混合运算。
问题分析:在计算机中,算术表达式由常量、变量、运算符和括号组成。
由于不同的运算符具有不同的优先级,又要考虑括号,因此,算术表达式的求值不可能严格地从左到右进行。
因而在程序设计时,借助栈实现。
设置运算符栈(字符型)和运算数栈(浮点型)辅助分析算符优先关系。
在读入表达式的字符序列的同时完成运算符和运算数的识别处理,然后进行运算数的数值转换在进行四则运算。
在运算之后输出正确运算结果,输入表达式后演示在求值中运算数栈内的栈顶数据变化过程,最后得到运算结果。
算法规定:输入形式:一个算术表达式,由常量、变量、运算符和括号组成(以字符串形式输入)。
为使实验更完善,允许操作数为实数,操作符为(、)、.(表示小数点)、+、-、*、/、^(表示乘方),用#表示结束。
输出形式:演示表达式运算的中间结果和整个表达式的最终结果,以浮点型输出。
程序功能:对实数内的加减乘除乘方运算能正确的运算出结果,并能正确对错误输入和无定义的运算报错,能连续测试多组数据。
测试数据:正确输入:12*(3.6/3+4^2-1)#输出结果:194.4无定义运算:12*(3.6/(2^2-4)+1)# 输出结果:表达式出错,除数为0,无意义 错误输入:12+s# 输出结果:ERROR ! 二、 概要设计拟采用两种类型的展分别对操作数和操作符进行操作。
程序中将涉及下列两个抽象数据类型:1、设定“操作数”的栈的抽象数据类型定义: ADT SqStack_f{数据对象:D={i a },+∈∈N i R a i数据关系:R1={<1,-i i a a >|1-i a ,D a i ∈,i=2,…,n}约定n a 端为栈顶,i a 端为栈底。
数据结构 设计性实验 有理数四则运算

<<数据结构>> 抽象数据类型实验报告题目有理数四则运算学院____ 计算机学院_____ 专业_ 网络工程年级班别____ 2007级三班___ 学号 3107007033 学生姓名_____江振辉__ 辅导教师_______李小妹________2009年 6月25 日1 、实验概要实验项目名称: 抽象数据类型的实现实验项目性质: 设计性实验所属课程名称: 数据结构实验计划学时: 62、实验目的对某个具体的抽象数据类型,运用课程所学的知识和方法,设计合理的数据结构,并在此基础上实现该抽象数据类型的全部基本操作。
通过本设计性实验,检验所学知识和能力,发现学习中存在的问题。
进而达到熟练地运用本课程中的基础知识及技术的目的。
实验要求如下:1.参加实验的学生应首先了解设计的任务,然后根据自己的基础和能力从中选择一题。
一般来说,选择题目应以在规定的时间内能完成,并能得到应有的锻炼为原则。
若学生对教材以外的相关题目较感兴趣,希望选作实验的题目时,应征得指导教师的认可,并写出明确的抽象数据类型定义及说明。
2. 实验前要作好充分准备,包括:理解实验要求,掌握辅助工具的使用,了解该抽象数据类型的定义及意义,以及其基本操作的算法并设计合理的存储结构。
3. 实验时严肃认真,要严格按照要求独立进行设计,不能随意更改。
注意观察并记录各种错误现象,纠正错误,使程序满足预定的要求,实验记录应作为实验报告的一部分。
4. 实验后要及时总结,写出实验报告,并附所打印的问题解答、程序清单,所输入的数据及相应的运行结果。
所用软件环境或工具:Dev-C++3.抽象数据类型ADT 抽象数据类型名{数据对象:<数据对象的定义>数据关系:<数据关系的定义>基本操作:<基本操作的定义>}ADT 抽象数据类型名例:线性表的表示二、类C语言语法5. 课程算法设计#include <stdio.h>#include <stdlib.h>#include <malloc.h>int GONGYUESHU(int m,int n)//*求最大公约数*// {int x,y,z;if(m<n){z=m;m=n;n=z;}x=m;y=n;while(y!=0){z=x%y;x=y;y=z;}return(x);}Exit()//*退出*//{printf("\n谢谢使用!制作者:计算机学院07级网络工程3班江振辉学号:3107007033");getchar();getchar();}int fen_Add(int q,int w,int v,int h)//*分数加法*//{int o,i,l,k,j;o=w*h;i=q*h+w*v;l=GONGYUESHU(o,i);k=o/l;j=i/l;printf("分数之和为%d/%d\n",j,k);}float Add(float a,float b)///*有理数加法*/{float sum;int q,w,v,h,j,x;char m;loop1:printf("******************************* 加法运算************************************\n");printf(" 1、整数、小数加法 2、分数加法 3、退出 \n");printf("******************************************************** ************************\n");printf("请选择1、2或3:");scanf("%d",&x);if(x!=1&&x!=2&&x!=3)printf("非法输入,请重新输入!");switch(x){case 1:{printf("请输入第一个数据:");scanf("%f",&a);printf("请输入第二个数据:");scanf("%f",&b);sum=a+b;printf("a+b=%f",sum);getchar();getchar();break;}case 2:{printf("输入第一个数的分子: ");scanf("%d",&q);printf("输入第一个数的分母: ");scanf("%d",&w);printf("输入第二个数的分子: ");scanf("%d",&v);printf("输入第二个数的分母: ");scanf("%d",&h);fen_Add(q,w,v,h);break;}case 3:{Exit();break;}default :{printf("输入有误!\n");goto loop1;break;}}if(x!=3)goto loop1;}int fen_Sub(int q,int w,int v,int h)///*分数减法*/ {int o,i,l,k,j;o=w*h;i=q*h-w*v;l=GONGYUESHU(o,i);k=o/l;j=i/l;printf("分数之差为%d/%d\n",j,k);}float Sub(float a,float b)//*有理数减法*//{float result;int q,w,v,h,j,x;char m;loop1:printf("******************************* 减法运算************************************\n");printf(" 1、整数、小数减法 2、分数减法 3、退出 \n");printf("******************************************************** ************************\n");printf("请选择1、2或3:");scanf("%d",&x);if(x!=1&&x!=2&&x!=3)printf("非法输入,请重新输入!");switch(x){case 1:{printf("请输入第一个数据:");scanf("%f",&a);printf("请输入第二个数据:");scanf("%f",&b);result=a-b;printf("a-b=%f",result);getchar();getchar();break;}case 2:{printf("输入第一个数的分子: ");scanf("%d",&q);printf("输入第一个数的分母: ");scanf("%d",&w);printf("输入第二个数的分子: ");scanf("%d",&v);printf("输入第二个数的分母: ");scanf("%d",&h);fen_Sub(q,w,v,h);break;}case 3:{Exit();break;}default :{printf("输入有误!\n");goto loop1;break;}}if(x!=3)goto loop1;}int fen_Mul(int q,int w,int v,int h)//*分数乘法*//{int o,i,l,k,j;o=w*h;i=q*v;l=GONGYUESHU(o,i);k=o/l;j=i/l;printf("分数之积为%d/%d\n",j,k);}float Mul(float a,float b)//*有理数乘法*//{float result;int q,w,v,h,j,x;char m;loop1:printf("******************************* 乘法运算************************************\n");printf(" 1、整数/小数乘法 2、分数乘法 3、退出 \n");printf("******************************************************** ************************\n");printf("请选择1、2或3:");scanf("%d",&x);if(x!=1&&x!=2&&x!=3)printf("非法输入,请重新输入!");switch(x)case 1:{printf("请输入第一个数据:");scanf("%f",&a);printf("请输入第二个数据:");scanf("%f",&b);result=a*b;printf("a*b=%f",result);getchar();getchar();break;}case 2:{printf("输入第一个数的分子: ");scanf("%d",&q);printf("输入第一个数的分母: ");scanf("%d",&w);printf("输入第二个数的分子: ");scanf("%d",&v);printf("输入第二个数的分母: ");scanf("%d",&h);fen_Mul(q,w,v,h);break;}case 3:{Exit();break;}default :{printf("输入有误!\n");goto loop1;break;}}if(x!=3)goto loop1;}int fen_Div(int q,int w,int v,int h)//*分数除法*// {int o,i,l,k,j;i=q*h;l=GONGYUESHU(o,i);k=o/l;j=i/l;printf("分数之积为%d/%d\n",j,k);}float Div(float a,float b)///*有理数除法*/{float result;int q,w,v,h,j,x;char m;loop1:printf("******************************* 除法运算************************************\n");printf(" 1、整数/小数除法 2、分数除法 3、退出 \n");printf("******************************************************** ************************\n");printf("请选择1、2或3:");scanf("%d",&x);if(x!=1&&x!=2&&x!=3)printf("非法输入,请重新输入!");switch(x){case 1:{printf("请输入第一个数据:");scanf("%f",&a);printf("请输入第二个数据:");scanf("%f",&b);result=a/b;printf("a/b=%f",result);getchar();getchar();break;}case 2:{printf("输入第一个数的分子: ");scanf("%d",&q);printf("输入第一个数的分母: ");scanf("%d",&w);printf("输入第二个数的分子: ");scanf("%d",&v);printf("输入第二个数的分母: ");scanf("%d",&h);fen_Div(q,w,v,h);break;}case 3:{Exit();break;}default :{printf("输入有误!\n");goto loop1;break;}}if(x!=3)goto loop1;}float feng(float z)//*求分子分母运算*//{int f,k,j,x;float elem=1000000;loop1:printf("***************************** 求分子分母运算*****************************\n");printf(" 1、输入数据 2、退出\n");printf("******************************************************** ************************\n");printf("请选择1或2:");scanf("%d",&x);if(x!=1&&x!=2)printf("非法输入,请重新输入!");if(x==1){printf("请输入一个有理数:");scanf("%f",&z);z=z*elem;f=GONGYUESHU(z,elem);j=elem/f;k=(int)z/f;printf("分子是%d,分母是%d\n",k,j);goto loop1;}if(x==2)Exit();}main()//*主程序*//{int x;float a,b,z;printf("\n**************************** 有理数四则运算******************************\n");printf(" 1、加法运算 2、减法运算\n");printf(" 3、乘法运算 4、除法运算\n");printf(" 5、求分子分母运算 6、退出\n");printf("******************************************************** ************************\n");loop3:printf("请选择运算类型:");scanf("%d",&x);printf("\n");switch(x){case 1:{Add(a,b);break;}case 2:{Sub(a,b);break;}case 3:{Mul(a,b);break;}case 4:{Div(a,b);break;}case 5:{feng(z);break;}case 6:{Exit();break;}default :{printf("输入有误!请重新选择:\n"); goto loop3;break;}}}5.测试及调试主函数调用图解:6.执行过程:测试两个有理数相除的运算,实现10除以5主菜单显示:做除法运算,选择4,ENTER。
数据结构实验四则运算-邹家运

中南林业科技大学涉外学院实验报告课题一课程名称数据结构年级系部 2010级理工系专业班级计算机科学与技术1班学生姓名邹家运学号 20107994任课教师余波2011年12月课题一:有理数的四则运算1.需求分析:a.设计一个可进行有理数运算的演示程序b.实现二个有理数的相加,相减,相乘,相除,以及求分子或求分母的运算,数据有用户自己定义。
c.测试数据用由用户自己定义。
2. 概要设计:为了实现这个功能,本程序充分利用了拆分字符的函数,根据用户点击的按钮不同进行不同的拆分。
3.详细设计:3.1 所需要的开发环境:java语言,windows7,eclipse,jdk1.63.2 在java中提供了split函数用来分隔字符,这样看来就变得简单了。
4.实验分析:这个实验中,把计算的类型分成二种情况,一种是计算非分数的,一种是计算分数的。
计算非分数运算:首先获取文本输入框里的表达式,再根据里面包含的运算符号,把表达式分成二个部分,再根据运算符号计算结果。
计算分数运算:首先获取文本输入框里的表达式,再根据里面包含的运算符号,把表达式分成二个部分,这里因为是分数,所以把这二个部分每个部分又要分别分成二个部分,这样我们就得到了这二个分数的分子,分母,再做相应的运算,化简结果。
4.1*特别声明*:在做分子除法运算的时候,这个程序里面用“!”作为其运算符,这样的话就利于分隔了,例如4/3!8/9;原因:因为进行分数除法运算时我们如果按“/”分隔表达式的话,这样不好处理,例如1/3/4/5,这样如果用”/”分隔就会出错。
5.实现代码:import java.awt.*;import javax.swing.*;import java.awt.Event;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;public class JiSuanQi extends JFrame implements ActionListener { //编写界面JPanel jp1,jp2,jp3;JButton jb1,jb2,jb3;JTextField jt;public static void main(String[] args) {new JiSuanQi();}public JiSuanQi(){jp1=new JPanel();jp2=new JPanel();jt=new JTextField(15);jb1=new JButton("计算非分数");jb1.addActionListener(this);jb2=new JButton("计算分数");jb2.addActionListener(this);jb3=new JButton("取消");jb3.addActionListener(this);jp1.add(jt);jp2.add(jb1);jp2.add(jb2);jp2.add(jb3);this.setLayout(new GridLayout(2,1));this.add(jp1);this.add(jp2);this.pack();this.setLocation(500,200);this.setVisible(true);this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);}@Overridepublic void actionPerformed(ActionEvent e) {String st=jt.getText();try {//处理非分数计算if(e.getSource()==jb1){if(st.contains("+")){//如果文本框中包含“+“String nums[]=st.split("\\+",2);//以“+“分隔成二个部分Float num1= Float.parseFloat(nums[0]);Float num2= Float.parseFloat(nums[1]);jt.setText((num1+num2)+"");}if(st.contains("-")){String nums[]=st.split("\\-",2);Float num1= Float.parseFloat(nums[0]);Float num2= Float.parseFloat(nums[1]);jt.setText((num1-num2)+"");}if(st.contains("*")){String nums[]=st.split("\\*",2);Float num1= Float.parseFloat(nums[0]);Float num2= Float.parseFloat(nums[1]);jt.setText((num1*num2)+"");}if(st.contains("/")){String nums[]=st.split("\\/",2);Float num1= Float.parseFloat(nums[0]);Float num2= Float.parseFloat(nums[1]);jt.setText((num1/num2)+"");}}} catch (Exception e2) {JOptionPane.showMessageDialog(this, "您的输入有误!!");}try {//处理分数计算if(e.getSource()==jb2){if(st.contains("+")){String nums[]=st.split("\\+",2);//拆分分数,得到四个部分String fen1[]=nums[0].split("\\/",2);String fen2[]=nums[1].split("\\/",2);int fenz1=Integer.parseInt(fen1[0]);//第一个分数的分子int fenm1=Integer.parseInt(fen1[1]);//第一个分数的分母int fenz2=Integer.parseInt(fen2[0]); //第二个分数的分子int fenm2=Integer.parseInt(fen2[1]); //第二个分数的分子int r1=fenz1*fenm2+fenz2*fenm1;int x=r1;int r2=fenm2*fenm1;int y=r2;//化简结果int r=x%y;while(r!=0){x=y;y=r;r=x%y;}jt.setText(r1/y+"/"+r2/y);}if(st.contains("-")){String nums[]=st.split("\\-",2);String fen1[]=nums[0].split("\\/",2);String fen2[]=nums[1].split("\\/",2);int fenz1=Integer.parseInt(fen1[0]);int fenm1=Integer.parseInt(fen1[1]);int fenz2=Integer.parseInt(fen2[0]);int fenm2=Integer.parseInt(fen2[1]);int r1=fenz1*fenm2-fenz2*fenm1;int x=r1;int r2=fenm2*fenm1;int y=r2;int r=x%y;while(r!=0){x=y;y=r;r=x%y;}jt.setText(r1/y+"/"+r2/y);}if(st.contains("*")){String nums[]=st.split("\\*",2);String fen1[]=nums[0].split("\\/",2);String fen2[]=nums[1].split("\\/",2);int fenz1=Integer.parseInt(fen1[0]);int fenm1=Integer.parseInt(fen1[1]);int fenz2=Integer.parseInt(fen2[0]);int fenm2=Integer.parseInt(fen2[1]);int r1=fenz1*fenz2;int x=r1;int r2=fenm2*fenm1;int y=r2;int r=x%y;while(r!=0){x=y;y=r;r=x%y;}jt.setText(r1/y+"/"+r2/y);}if(st.contains("!")){String nums[]=st.split("\\!",2);String fen1[]=nums[0].split("\\/",2);String fen2[]=nums[1].split("\\/",2);int fenz1=Integer.parseInt(fen1[0]);int fenm1=Integer.parseInt(fen1[1]);int fenz2=Integer.parseInt(fen2[0]);int fenm2=Integer.parseInt(fen2[1]);int r1=fenz1*fenm2;int x=r1;int r2=fenm1*fenz2;int y=r2;int r=x%y;while(r!=0){x=y;y=r;r=x%y;}jt.setText(r1/y+"/"+r2/y);}}} catch (Exception e2) {// TODO: handle exceptionJOptionPane.showMessageDialog(this, "您的输入有误!!"); }if(e.getSource()==jb3){System.exit(1);}}}6.测试的结果○1计算非分数的结果6.1加法6.2减法6.3乘法6.4除法○2计算分数的结果6.5加法6.6减法6.7乘法6.8除法。
广工 数据结构 设计性实验 有理数四则运算 报告

《数据结构》设计性实验题目 _第2题有理数四则运算_ 学院计算机学院专业年级班别学号学生姓名指导教师思路理论设计难度系数代码总成绩2013 年 6 月29 日序号:一、设计任务要求问题描述:设计一个可进行有理数运算的演示程序。
基本要求:实现两个有理数相加、相减、相乘、相除以及求分子或分母的运算。
测试数据:有读者指定。
选作内容:事项两个有理数相除的运算。
二、主要算法流程图三、主要代码int MaxCommonisor(int m,int n)//*求最大公约数*// {int x,y,z; if(m<n){z=m;m=n;n=z;} x=m;y=n; while(y!=0) {z=x%y; x=y; y=z; }return(x); }Exit()//*退出*// {主程序加法 减法 乘法 除法 小数、整数加法分数加法 求分子分母小数整数减法分数减法 小数整数乘法分数乘法 小数整数除法分数除法}int fraction_Add(int numerator_1,int denominator_1,int numerator_2,int denominator_2)//*分数加法*//{int o,i,l,k,j;o=denominator_1*denominator_2;i=numerator_1*denominator_2+denominator_1*numerator_2;l=MaxCommonisor(o,i);k=o/l;j=i/l;printf("运算结果为%d/%d+%d/%d=%d/%d\n",numerator_1,denominator_1,numerator_2,denominator_2,j,k); }float Add(float a,float b)///*有理数加法*/{float sum;int numerator_1,denominator_1,numerator_2,denominator_2,j,x;char m;loop1:printf("******************************* 加法运算************************************\n");printf("\n");printf(" 1、整数、小数加法2、分数加法3、退出\n");printf("\n");printf("********************************************************************* ***********\n");printf("请选择1、2或3:");scanf("%d",&x);if(x!=1&&x!=2&&x!=3)printf("非法输入,请重新输入!");switch(x){case 1:{printf("请输入第一个数据:");scanf("%f",&a);printf("请输入第二个数据:");scanf("%f",&b);sum=a+b;printf("运算结果为%f+%f=%f",a,b,sum);getchar();getchar();break;}case 2:{printf("输入第一个数的分子: ");scanf("%d",&numerator_1);printf("输入第一个数的分母:");scanf("%d",&denominator_1);printf("输入第二个数的分子:");scanf("%d",&numerator_2);printf("输入第二个数的分母:");scanf("%d",&denominator_2);fraction_Add(numerator_1,denominator_1,numerator_2,denominator_2);break;}case 3:{Exit();break;}default :{printf("输入有误!\n");goto loop1;break;}}if(x!=3)goto loop1;}int fraction_Sub(int numerator_1,int denominator_1,int numerator_2,int denominator_2)///*分数减法*/{int o,i,l,k,j;o=denominator_1*denominator_2;i=numerator_1*denominator_2-denominator_1*numerator_2;l=MaxCommonisor(o,i);k=o/l;j=i/l;printf("运算结果为%d/%d-%d/%d=%d/%d\n",numerator_1,denominator_1,numerator_2,denominator_2,j,k); }float Sub(float a,float b)//*有理数减法*//{float result;int numerator_1,denominator_1,numerator_2,denominator_2,j,x;char m;loop1:printf("******************************* 减法运算************************************\n");printf("\n");printf(" 1、整数、小数减法2、分数减法3、退出\n");printf("\n");printf("********************************************************************* ***********\n");printf("请选择1、2或3:");scanf("%d",&x);if(x!=1&&x!=2&&x!=3)printf("非法输入,请重新输入!");switch(x){case 1:{printf("请输入第一个数据:");scanf("%f",&a);printf("请输入第二个数据:");scanf("%f",&b);result=a-b;printf("%f-%f=%f",a,b,result);getchar();getchar();break;}case 2:{printf("输入第一个数的分子: ");scanf("%d",&numerator_1);printf("输入第一个数的分母:");scanf("%d",&denominator_1);printf("输入第二个数的分子:");scanf("%d",&numerator_2);printf("输入第二个数的分母:");scanf("%d",&denominator_2);fraction_Sub(numerator_1,denominator_1,numerator_2,denominator_2);break;}case 3:{Exit();break;}default :{printf("输入有误!\n");goto loop1;break;}}if(x!=3)goto loop1;}int fraction_Mul(int numerator_1,int denominator_1,int numerator_2,int denominator_2)//*分数乘法*//{int o,i,l,k,j;o=denominator_1*denominator_2;i=numerator_1*numerator_2;l=MaxCommonisor(o,i);k=o/l;j=i/l;printf("运算结果为%d/%d * %d/%d = %d/%d\n",numerator_1,denominator_1,numerator_2,denominator_2,j,k);}float Mul(float a,float b)//*有理数乘法*//{float result;int numerator_1,denominator_1,numerator_2,denominator_2,j,x;char m;loop1:printf("******************************* 乘法运算************************************\n");printf("\n");printf(" 1、整数/小数乘法2、分数乘法3、退出\n");printf("\n");printf("********************************************************************************\n");printf("请选择1、2或3:");scanf("%d",&x);if(x!=1&&x!=2&&x!=3)printf("非法输入,请重新输入!");switch(x){case 1:{printf("请输入第一个数据:");scanf("%f",&a);printf("请输入第二个数据:");scanf("%f",&b);result=a*b;printf("%f * %f = %f",a,b,result);getchar();getchar();break;}case 2:{printf("输入第一个数的分子: ");scanf("%d",&numerator_1);printf("输入第一个数的分母:");scanf("%d",&denominator_1);printf("输入第二个数的分子:");scanf("%d",&numerator_2);printf("输入第二个数的分母:");scanf("%d",&denominator_2);fraction_Mul(numerator_1,denominator_1,numerator_2,denominator_2);break;}case 3:{Exit();break;}default :{printf("输入有误!\n");goto loop1;break;}}if(x!=3)goto loop1;}int fraction_Div(int numerator_1,int denominator_1,int numerator_2,int denominator_2)//*分数除法*//{int o,i,l,k,j;o=denominator_1*numerator_2;i=numerator_1*denominator_2;l=MaxCommonisor(o,i);k=o/l;j=i/l;printf("运算结果为%d/%d / %d/%d = %d/%d\n",numerator_1,denominator_1,numerator_2,denominator_2,j,k);}float Div(float a,float b)///*有理数除法*/{float result;int numerator_1,denominator_1,numerator_2,denominator_2,j,x;char m;loop1:printf("******************************* 除法运算************************************\n");printf("\n");printf(" 1、整数/小数除法2、分数除法3、退出\n");printf("\n");printf("********************************************************************* ***********\n");printf("请选择1、2或3:");scanf("%d",&x);if(x!=1&&x!=2&&x!=3)printf("非法输入,请重新输入!");switch(x){case 1:{printf("请输入第一个数据:");scanf("%f",&a);printf("请输入第二个数据:");scanf("%f",&b);result=a/b;printf("a/b=%f",result);getchar();getchar();break;}case 2:{printf("输入第一个数的分子: ");scanf("%d",&numerator_1);printf("输入第一个数的分母:");scanf("%d",&denominator_1);printf("输入第二个数的分子:");scanf("%d",&numerator_2);printf("输入第二个数的分母:");scanf("%d",&denominator_2);fraction_Div(numerator_1,denominator_1,numerator_2,denominator_2);break;}case 3:{Exit();break;}default :{printf("输入有误!\n");goto loop1;break;}}if(x!=3)goto loop1;}float feng(float z)//*求分子分母运算*//{int f,k,j,x;float elem=1000000;loop1:printf("***************************** 求分子分母运算*****************************\n");printf("\n");printf(" 1、输入数据2、退出\n");printf("\n");printf("********************************************************************* ***********\n");printf("请选择1或2:");scanf("%d",&x);if(x!=1&&x!=2)printf("非法输入,请重新输入!");if(x==1){printf("请输入一个有理数:");scanf("%f",&z);z=z*elem;f=MaxCommonisor(z,elem);j=elem/f;k=(int)z/f;printf("分子是%d,分母是%d\n",k,j);goto loop1;}if(x==2)Exit();}main()//*主程序*//{int x;float a,b,z;printf("\n**************************** 有理数四则运算******************************\n");printf("\n");printf(" 1、加法运算2、减法运算\n");printf(" 3、乘法运算4、除法运算\n");printf(" 5、求分子分母运算6、退出\n");printf("\n");printf("********************************************************************* ***********\n");loop3:printf("请选择运算类型:");scanf("%d",&x);printf("\n");switch(x){case 1:{Add(a,b);break;}case 2:{Sub(a,b);break;}case 3:{Mul(a,b);break;}case 4:{Div(a,b);break;}case 5:{feng(z);break;}case 6:{Exit();break;}default :{printf("输入有误!请重新选择:\n");goto loop3;break;}}}六、实验截图1. 测试用例加法:整数:1+1小数:1.2+3.4分数:1/2+2/3减法:整数:9-8,8-9小数:9.8-7.6,7.6-9.8分数:1/2-1/3,1/3-1/2 乘法:整数:2*3小数:1.2*2.3分数:1/2*1/3除法:整数:1÷2,3÷2小数:1.2÷3.4,3.4÷1.2分数:1/2÷1/3,1/3÷1/2 求分子分母运算:1.2,0.42. 程序截图主界面加法减法乘法除法求分子分母运算3. 实验结果分析运算结果全部正确七、小结其实有理数四则运算用c写的话还是很简单的,但我自己写的时候并没感觉用到了数据结构的知识。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
南华大学实验报告(201 6 ~201 7 学年度第一学期)数据结构课程名称表达式求值实验名称姓名XX 学号XX专业计算机类班级计类九班地点南华大学教师余童兰1.实验目的及要求实验二栈与队列1.实验目的:掌握栈的特点及其描述方法,掌握顺序表与链式存储结构实现一个栈或队列,掌握栈与队列中各种等基本操作及典型应用算法。
要求自行设计链式栈和链式队列类。
2.实验内容与要求:以下题目任选其一,实验报告格式与实验1一致。
要求自行设计基础类:链式栈或链式队列类(必须是链式存储)。
1)表达式求值。
用户输入一个包含“+”、“-”、“*”、“/”、正整数和圆括号的合法数学表达式,利用栈完成该表达式的求解;2)迷宫问题。
以一维数组Maze[m+2][n+2]数组描述一个迷宫,元素。
值为0表示通道,值为1表示墙壁,以Maze[1][1]表示迷宫的入口,而maze[m][n]表示迷宫的出口,外层数据全为1表示外围墙壁,Maze数组内层数据表达一个迷宫(数据来源于输入或随机赋值),打印一条如何从Maze[1][1]到达出口Maze[m][n]的路径,若无解,则打印“无解”信息;3)舞会模拟。
设舞厅能同时容纳m对舞伴共舞,期间播放n支舞曲。
会上男士们和女士们进入舞厅时,各自排成一队。
跳舞开始时,依次从男队和女队的队头上各出一人配成舞伴,跳完后重新排队。
请输入男队队员个数与名字,女队队员个数与名字,n与舞曲名称,舞厅容量m,打印各舞曲播放时,跳舞的舞伴配对情况;2.实验内容1.1各算法基本思想及各函数流程图该节描述实验中各类的UML类图及关联;类中各个操作的基本思想,算法流程图及时空复杂度分析;30分,评分标准:图,表,术,语等规范度15;完整详细度15;)LinkStack类UML图:Complex_Caculate() 核心函数流程图Caculate函数流程图:Complex_Caculate()函数思想:对输入的字符进行一个个处理,如果是多位数就调用atof()转换成浮点数。
同时对括号进行特殊处理运算。
考虑四种情况:当前运算符大于栈顶运算符,左右括号;当前运算符小于栈顶运算符;当前运算符等于栈顶运算符;结束标志#。
对着四种情况进行相应的处理。
用链栈作为数据结构,空间复杂度随实践规模大小决定为O(n)。
对输入的表达式字符一个个读取进行处理,时间复杂度为O(n)。
2.2 源程序(要求有20%以上的注释)(25分;评分标准:注释10;程序风格5;程序功能完整5;容错性及程序效率5;)//Main.cpp#include <iostream>#include "LinkStack.h"#include <stdlib.h>#include <stdio.h>#include <math.h>using namespace std;//设为全局变量是为了方便Computer的调用LinkStack<double> OPND;//存放数字的栈LinkStack<char> OPTR;//存放运算符的栈int to=-1,excel[]={0,0,2,1,2,1,0,2},i=0,counter=0;//依次为栈顶运算符优先级,运算符优先级表...char a[100];//临时存放表达式double Caculate(double b,double c,char d){switch (d){case '+': /*处理加法*/return b+c;case '-': /*处理减法*/return b-c;case '*': /*处理乘法*/return b*c;case '/': /*处理除法*/if (0 == c) //除零情况{cout<<"Division by zero!\n"<<endl;system("pause");exit(1);}elsereturn b/c;case '^':return pow(b,c);case '%':return (int)b%(int)c;default://存在非法运算符的处理cout<<"计算停止!有非法字符: "<<d<<endl;exit(1);}return 0;}void Computer()//出栈两个运算对象,出栈一个运算符,进行计算。
更新顶部运算符优先级{double b=OPND.Pop();//运算对象1double c=OPND.Pop();//运算对象2char d=OPTR.Pop();//运算符to=excel[a[i]%10];//更新顶部运算符优先级OPND.Push(Caculate(c,b,d));//运算结果入栈}void Complex_Caculate()//表达式求值主要函数{OPTR.Push('#');//初始化终止符int to2=-1,flag=0,k=1;//遇到括号前的运算符优先级、是否存在括号的标志char c;while((c=getchar())!='\n')//输入四则运算符表达式{a[counter++]=c;}a[counter]='#';//尾部终止符while(1)//遍历处理字符{if(a[i]=='#')//终止符情况(结束运算){while(OPTR.GetTop()!='#')//处理两个栈中剩下的对象{double b=OPND.Pop();double c=OPND.Pop();char d=OPTR.Pop();if(d!='(')OPND.Push(Caculate(c,b,d));}break;}if(a[i]>='0'&&a[i]<='9')//数字就存入运算对象栈{ int j=i;char b[16];k=0;while(a[j]>='0'&&a[j]<='9')//处理多位数{b[k]=a[j];k++,j++;}b[k]='\0';OPND.Push(atof(b));//ATOF转换为浮点数}else if(a[i]>65&&a[i]!='^'&&a[i]!='%'){cout<<"有非法字符!"<<endl;exit(1);}else if(excel[a[i]%10]>to||a[i]==')'||a[i]=='(')//当前字符是运算符且优先级比OPTR栈顶元素高,或者运算符是()的情况{ if(a[i]=='('){flag=1;//有括号标志记为1OPTR.Push(a[i]);to2=to;//记录括号之前运算符的优先级to=excel[a[i]%10];//记录当前运算符的优先级}else if(a[i]==')')//括号匹配{while(OPTR.GetTop()!='(')//处理左括号之前的所有的运算对象和运算符{ double b=OPND.Pop();double c=OPND.Pop();char d=OPTR.Pop();if(d!='('){OPND.Push(Caculate(c,b,d));//入栈计算结果}elsebreak;}flag=0;//有括号标志记为0OPTR.Pop();//出栈左括号to=to2;//运算符优先级变为左括号之前的运算符优先级}else{//当前字符是运算符且优先级比OPTR栈顶元素高OPTR.Push(a[i]);to=excel[a[i]%10];}} else if(excel[a[i]%10]<to)//当前字符是运算符且优先级比OPTR 栈顶元素低{if(flag!=1)//无括号时处理,应对例如1+1*2只计算1*2而未计算剩下的加法1+2{while(OPTR.GetTop()!='#')Computer();OPTR.Push(a[i]);}else//有括号时处理,应对例如1+1*2只计算1*2而未计算剩下的加法1+2{while(OPTR.GetTop()!='(')Computer();OPTR.Push(a[i]);}}else//当前字符是运算符且优先级与OPTR栈顶元素相同{if(flag!=1)//无括号时{Computer();OPTR.Push(a[i]);}else{//有括号时while(OPTR.GetTop()!='(')Computer();OPTR.Push(a[i]);}}i+=(k);//下一个字符k=1;}cout<<"结果:"<<OPND.GetTop()<< endl;//输出结果}int main(){Complex_Caculate();return 0;}//LinkStack.htemplate <class DataType>struct Node{DataType data;struct Node<DataType> * next;};template <class DataType>class LinkStack{public:LinkStack(){top=NULL;};~LinkStack(){};void Push(DataType x);//入栈函数DataType Pop();DataType GetTop(){if(top!=NULL) return top->data;}//返回栈顶元素private:Node<DataType> *top;//头指针};template <class DataType>void LinkStack<DataType>::Push(DataType x)//头插法原理入栈{Node<DataType> *s;s=new Node<DataType>;s->data=x;s->next=top;top=s;}template <class DataType>DataType LinkStack<DataType>::Pop()//出栈{ DataType x;Node<DataType> *p;if(top==NULL)throw "下溢";x=top->data;p=top;top=top->next;delete p;return x;}3.实验结果(5分;切屏显示)南华大学实验报告b4. 实验总结分析(15分;实验过程心得感受;评分标准:表达流畅5;完整详细10)实验用栈的数据结构实现,个人觉得难点在于有括号时的运算,一旦有括号则运算顺序就会不同,所以要记录括号之前的运算符优先级,等括号匹配完成运算符优先级变回到无括号时的。