中南大学数据结构课程设计报告.docx
《中南大学数据结构课程设计报告.docx》由会员分享，可在线阅读，更多相关《中南大学数据结构课程设计报告.docx（24页珍藏版）》请在冰豆网上搜索。
中南大学数据结构课程设计报告
信息科学与工程学院
课程设计报告书
课程名称数据结构
设计题目算术表达式求值
专业班级电子信息工程1002
学号0909101123
姓名杨家骏
指导教师李登
2012年7月
目录
●问题描述
●基本要求
●数据结构的设计
●软件模块结构图
●程序设计思想
●程序流程图
●源程序
●调试分析
●测试数据
●用户使用手册
●心得体会
一：
问题描述
从键盘上输入算术表达式，包括括号，
（1）判断表达式是否是正常表达式；
（2）计算出一般表达式（类似如a*b+c/d-e）的值，（3）并能实现一元多项式相加。
二：
基本要求
（1）程序对所输入的友达式作简单的判断，如表达式有错，能给出适当的提示
（2）能处理单目运算符：
十和一。
（3）已知
和
，并且在A（x）和B（x）中指数相差很多，求A（x）=A（x）+B（x）。
要求设计存储结构表示一元多项式，设计算法实现一元多项式相加。
三：
数据结构的分析
根据本课程设计题目要求，可总体分为三个大的模块。
分别是判断表达式正确与否（模块1）、表达式求值设计（模块2）、实现一元多项式相加（模块3）。
所以下面分别对三个大模块进行大概的各类分析。
需求分析
模块1：
能够处理以字符序列的形式输入的不含变量的实数表达式，能够正确处理负数与小数，能够判断表达式是否语法正确（即不能出现两符号连续出现的情况，包括分母不为零的情况）。
模块2：
能正确实现对算术四则混合运算表达式的求值。
以字符串的形式输入表达式，以“#”结束；在计算的最终的答案将显示在屏幕上；能够将计算中遇到的问题和结果以文件的形式予以存储。
模块3：
能够实现一元多项式相加，并予以存储。
②概要设计
模块1：
数据结构类型：
#defineSTACK_INIT_SIZT100;
#defineSTACKINCREMENT10
typedefstruct{
SElemType*base;
SElemType*top;
intstacksize;
}
SqStack;
模块2：
数据结构类型
typedefstruct
{
intdata[MAX];
inttop;
}
SeqStack;
SeqStack*OPTR,*OPND;
模块3：
数据结构类型：
typedefintElemType;
typedefstructCLNode
{
ElemTypecoef;
ElemTypeexp;
structCLNode*next;
}CLNode,*CLinkList
③详细设计
模块1：
voidmain（）{
SqStack_TOPTR;SqStack_NOPND;
floata,b,i;chartheta,c,x;
InitStack_T（&OPTR）;Push_T（&OPTR,’#’）;
InitStack_N（&OPND）;
printf（“请输入表达式关以’#’结尾：
\n”）;
c=getchar（）;
if（c==35||（c>=40&&c<=43）||c==45||（c>=47&&c<=57））
{
while（c!
=’#’||GetTop_T（&OPTR）!
=’#’）
{
if（c>=48&&c<=57）
{
i=（float）c-48;
Push_N（&OPND,i）;
c=getchar（）;
}
else
{
switch（Precede（GetTop_T（&OPND）,c））
{
case’<’:
Push_T（&OPTR,c）;c=getchar（）;break;
case’=’:
x=Pop_T（&OPTR）;c=getchar（）;break;
case’>’:
theat=Pop_T（&OPTR）;b=Pop_N（&OPND）;
a=Pop_N（&OPND）;Push_N（&OPND,Operate（a,theta,b））;
break;
}
}
}
printf（“结果是%f\n”,GetTop_N（&OPND））;
}
elseprintf（“输入错误！
\n”）;
}
模块2：
voidmain（）
{
SeqStack*OPTR,*OPND;//定义两个栈
intw,op,temp;
inta,b,is_err;
OPTR=Init_SeqStack（）;//初始化运算符optr堆栈
OPND=Init_SeqStack（）;//初始化运算数opnd堆栈
is_err=Push（OPTR,'#'）;//首先将#进运算符栈
system（"cls"）;
printf（"------------------中缀表达式求值程序------------------\n\n"）;
printf（"-----使用方法：
连续输入表达式，以#号结束，最后按回车键。
\n\n"）;
printf（"-----可使用的运算符包括：
（、）、^、*、/、%、+、-\n\n"）;
printf（"-----注意：
运算数为0-9十个数字。
\n\n"）;
printf（"-----请输入表达式：
"）;
w=getchar（）;
while（w!
='#'||GetTop（OPTR）!
='#'）//算符栈顶元素不是#（表达式非0，执行语句）
{
if（Is_OPND（w））//w为数值，返回1，w为算符，返回0
{
Push（OPND,w-'0'）;//数值进opnd堆栈
w=getchar（）;//循环
}
else
switch（Precede（GetTop（OPTR）,w））//否则，比较optr堆栈中栈顶的算符与getchar（）函数读入的算符的优先级
{
case-1:
//栈外算符优先级高，继续入栈
is_err=Push（OPTR,w）;//入栈操作
w=getchar（）;//循环
break;
case0:
//?
?
?
is_err=Pop（OPTR,&temp）;
w=getchar（）;
break;
case1:
//栈内算符优先级高
is_err=Pop（OPND,&b）;//将栈顶的元素赋予后一个变量
is_err=Pop（OPND,&a）;
is_err=Pop（OPTR,&op）;
is_err=Push（OPND,Execute（a,op,b））;
break;
}
}
printf（"-----结果为：
%d\n",GetTop（OPND））;
}
模块3：
voidAddpoly（PolyNode*pa,PolyNode*pb） //两个多项式相加
{
PolyNode*p,*q,*r,*temp; //temp用来存放临时结点
floatsum;
p=pa->next;
q=pb->next;
r=pa;
while（p&&q）
{
if（p->expexp） //p指向的项指数小于q，尾指针指向p，且将p指向链表的下一结点
{
r=p;
p=p->next;
}
elseif（p->exp==q->exp） //指数相等时，系数相加
{
sum=p->coef+q->coef;
if（sum!
=0）
{
p->coef=sum;
r=p;
}
else //系数相加为0
{
r->next=p->next;
free（p）;
}
p=r->next;
temp=q;
q=q->next;
}
else //q指向项指数小于p时，将q加入多项式中
{
temp=q->next;
q->next=p;
r->next=q;
r=q;
q=temp;
}
}
if（q）
r->next=q;
free（pb）;
}
voidPrint（PolyNode*p） //打印多项式
{
inti=0;
while（p->next）
{
p=p->next;
i++;
printf（" %g*x^%d\n",p->coef,p->exp）;
}
printf（"一共有%d项\n",i）;
}
voidmain（） //主函数
{
PolyNode*pa,*pb;inti;
printf（"\n**********^-^欢迎光临^-^**********\n"）;
printf（"\n请输入多项式a（按指数递增顺序输入）:
\n"）;
pa=Createpoly（）;
Print（pa）;
printf（"\n请输入多项式b（按指数递增顺序输入）:
\n"）;
pb=Createpoly（）;
Print（pb）;
printf（"\n多项式相加结果是:
\n"）;
Addpoly（pa,pb）;
Print（pa）;
printf（"\n"）;
}
④调试分析
模块1：
未实现功能
模块2：
模块3：
四：
软件模块结构图
模块1、2：
模块3：
五：
程序设计思想
模块1：
看到程序要求，头脑里就有一定的逻辑思路和关系：
先判断括号是否对称，然后再考虑是否有符号连续的情况。
最后看是否运算数位比符号位多1。
模块2：
算术表达式中有加减乘除，以及乘方和括号等运算关系和法则，又考虑到有运算先后的关系。
故需采用不同的存储结构来存储，所以要用到OPTR和OPND两个栈，分别用来存储运算符合运算数，并且规定‘#’是最低运算级，所以需用‘#’表示表达式结束。
模块3：
第一眼看到要求以及多项式的形式，可以采用顺序存储结构来实现，但是一般应用中多项式的次数过大，难以确定链表的长度，所以此处用链式存储结构来实现。
六：
程序流程图
七：
源程序
#include"stdio.h"
#include"stdlib.h"
#include
#defineOK1
#defineERROR0
#defineOVERFLOW0
#defineMAX100
typedefstruct{
char*base;
char*top;
intstacksize;
}SqStack_T;
typedefstruct{
float*base;
float*top;
intstacksize;
}SqStack_N;
voidInitStack_T（SqStack_T*S）{
（*S）.base=（char*）malloc（STACK_INIT_SIZE*sizeof（char））;
if（!
（*S）.base）exit（OVERFLOW）;
（*S）.top=（*S）.base;
（*S）.stacksize=STACK_INIT_SIZE;
}
voidInitStack_N（SqStack_N*S）{
（*S）.base=（float*）malloc（STACK_INIT_SIZE*sizeof（float））;
if（!
（*S）.base）exit（OVERFLOW）;
（*S）.top=（*S）.base;
（*S）.stacksize=STACK_INIT_SIZE;
}
charGetTop_T（SqStack_T*S）{
chare;
if（（*S）.top==（*S）.base）returnERROR;
e=*（（*S）.top-1）;
returne;
}
floatGetTop_N（SqStack_N*S）{
floate;
if（（*S）.top==（*S）.base）returnERROR;
e=*（（*S）.top-1）;
returne;
}
charPush_T（SqStack_T*S,chare）{
if（（*S）.top-（*S）.base>=（*S）.stacksize）{
（*S）.base=（char
*）realloc（（*S）.base,（（*S）.stacksize+STACKINCREMENT）*sizeof（char））;
if（!
（*S）.base）exit（OVERFLOW）;
（*S）.top=（*S）.base+（*S）.stacksize;
（*S）.stacksize+=STACKINCREMENT;
}
*（（*S）.top）++=e;
returnOK;
}
floatPush_N（SqStack_N*S,floate）{
if（（*S）.top-（*S）.base>=（*S）.stacksize）{
（*S）.base=（float
*）realloc（（*S）.base,（（*S）.stacksize+STACKINCREMENT）*sizeof（float））;
if（!
（*S）.base）exit（OVERFLOW）;
（*S）.top=（*S）.base+（*S）.stacksize;
（*S）.stacksize+=STACKINCREMENT;
}
*（（*S）.top）++=e;
returnOK;
}
charPop_T（SqStack_T*S）{
chare;
if（（*S）.top==（*S）.base）returnERROR;
e=*（--（*S）.top）;
returne;
}
floatPop_N（SqStack_N*S）{
floate;
if（（*S）.top==（*S）.base）returnERROR;
e=*（--（*S）.top）;
returne;
}
charm[7]="+-*/（）#";
charn[7][7]={">><<<>>",">><<<>>",">>>><>>",">>>><>>","<<<<<="
">>>>>>","<<<<<="};
charPrecede（chara,charb）{
inti=0,j=0;
while（m[i]!
=a）
i++;
while（m[j]!
=b）
j++;
return（n[i][j]）;
}
floatOperate（floata,chartheta,floatb）{
floatr;
switch（theta）{
case'+':
r=a+b;break;
case'-':
r=a-b;break;
case'*':
r=a*b;break;
case'/':
if（b!
=0）r=a/b;
elseprintf（"输入错误!
"）;
break;
}
returnr;
}
voidmain（）{
SqStack_TOPTR;
SqStack_NOPND;
floata,b,i;
chartheta,c,x;
InitStack_T（&OPTR）;Push_T（&OPTR,'#'）;
InitStack_N（&OPND）;
printf（"请输入表达式并以'#'结尾:
\n"）;
c=getchar（）;
if（c==35||（c>=40&&c<=43）||c==45||（c>=47&&c<=57））
{
while（c!
='#'||GetTop_T（&OPTR）!
='#'）
{
if（c>=48&&c<=57）
{
i=（float）c-48;
Push_N（&OPND,i）;
c=getchar（）;
}
else
{
switch（Precede（GetTop_T（&OPTR）,c））
{
case'<':
Push_T（&OPTR,c）;c=getchar（）;break;
case'=':
x=Pop_T（&OPTR）;c=getchar（）;break;
case'>':
theta=Pop_T（&OPTR）;b=Pop_N（&OPND）;
a=Pop_N（&OPND）;
Push_N（&OPND,Operate（a,theta,b））;break;
}
}
}printf（"结果是%f\n",GetTop_N（&OPND））;
}
elseprintf（"输入错误!
\n"）;
}
}
typedefstruct
{
intdata[MAX];
inttop;
}SeqStack;
SeqStack*Init_SeqStack（）//初始化堆栈
{
SeqStack*s;
s=newSeqStack;//申请栈空间
if（!
s）
{
printf（"空间不足，初始化失败！
"）;
returnNULL;//未申请到足够大的存储空间，返回空指针
}
else
{
s->top=-1;//初始化栈顶指针
printf（"堆栈初始化成功!
\n按回车键继续..."）;
returns;//申请到栈空间，返回栈空间地址
}
}
intEmpty（SeqStack*s）{//判空栈
if（s->top==-1）
return1;//栈顶指针指向栈底，空栈
else
return0;
}
intPush（SeqStack*s,intx）{//进栈
if（s->top==MAX-1）
return0;//栈满不能入栈，返回错误代码0
else
{s->top++;//栈顶指针向上移动
s->data[s->top]=x;//将x至入新的栈顶
return1;//入栈成功，返回成功代码1
}
}
intPop（SeqStack*s,int*x）{//出栈
if（Empty（s））
return0;//栈空不能出栈，返回错误代码0
else
{*x=s->data[s->top];//保存栈顶元素值
s->top--;//栈顶指针向下移动
return1;//返回成功代码1
}
}
intGetTop（SeqStack*s）//取栈顶元素
{
return（s->data[s->top]）;
}
intIs_OPND（charx）//判断运算符和运算数
{
inttemp;
temp=1;
switch（x）
{
case'^':
case'*':
case'/':
case'%':
case'+':
case'-':
case'（':
case'）':
case'#':
temp=0;
}
return（temp）;
}
intPrecede（charin,charout）
{
intc_temp1,c_temp2;
inttemp;
switch（in）
{
case'^':
c_temp1=5;break;
case'*':
case'/':
case'%':
c_temp1=4;break;
case'+':
case'-':
c_temp1=2;break;
case'（':
c_temp1=0;break;
case'）':
c_temp1=6;break;
case'#':
c_temp1=-1;
}
switch（out）
{
case'^':
c_temp2=5;break;
case'*':
case'/':
case'%':
c_temp2=3;break;
case'+':
case'-':
c_temp2=1;break;
case'（':
c_temp2=6;break;
case'）':
c_temp2=0;break;
case'#':
c_temp2=-1;
}
if（c_temp1if（c_temp1==c_temp2）temp=0;
if（c_temp1>c_temp2）temp=1;//栈内算符优先级高，运算
return（temp）;
}
intExecute（inta,charop,intb）{
ints;
switch（op）
{
case'^':
s=（int）pow（a,b）;break;
case'*':
s=a*b;break;
case'/':
s=a/b;break;
case'%':
s=a%b;break;
case'+':
s=a+b;break;
case'-':
s=a-b;break;
}return（s）;
}
voidmain（）
{
SeqStack*OPTR,*OPND;//定义两个栈
intc,theta,temp;
inta,b,is_err;
OPTR=Init_SeqStack（）;//初始化运算符optr堆栈
OPND=Init_SeqStack（）;//初始化运算数opnd堆栈
is_err=Push（OPTR,'#'）;//首先将#进运算符栈
system（"cls"）;
printf（"-------------
升级会员 