数据结构实验报告文档格式.docx
《数据结构实验报告文档格式.docx》由会员分享，可在线阅读，更多相关《数据结构实验报告文档格式.docx（33页珍藏版）》请在冰豆网上搜索。
【具体算法】
//按指数降序排列;
voidsort_HtoL（LinkList*L）
{
LinkList*p,*q;
inttemp_coef,temp_exp;
for（p=L->
next;
p->
next!
=NULL;
p=p->
next）
for（q=p->
q!
q=q->
{
if（p->
exp<
q->
exp）
{
temp_exp=p->
exp;
//交换指数;
p->
exp=q->
q->
exp=temp_exp;
temp_coef=p->
coef;
//同时交换系数;
coef=q->
coef=temp_coef;
}
}
}
//合并同类项;
voidSimplify（LinkList*L）
LinkList*p;
p=L->
while（p->
=NULL）
{
if（p->
exp==p->
next->
p->
coef=p->
coef+p->
//合并;
next=p->
else
p=p->
}
//LA+LB=LC;
voidSum（LinkList*LA,LinkList*LB,LinkList*&
LC）
LinkList*p,*q,*s,*r;
p=LA->
q=LB->
inttemp;
LC=（LinkList*）malloc（sizeof（LinkList））;
//创建头结点;
r=LC;
while（p!
=NULL&
&
q!
=NULL）
if（p->
exp>
exp）
s=（LinkList*）malloc（sizeof（LinkList））;
//复制结点;
s=p;
r->
next=s;
r=s;
p=p->
//指向LA的p指针后移;
elseif（p->
s->
exp=q->
coef=q->
q=q->
//指向LB的q指针后移;
else//p->
exp
temp=p->
coef+q->
//系数相加;
if（temp!
=0）//系数之和不为0时创建新结点
s=（LinkList*）malloc（sizeof（LinkList））;
//复制结点
s->
exp=p->
coef=temp;
r->
r=s;
if（q!
=NULL）
p=q;
//复制余下的结点
while（p!
s=（LinkList*）malloc（sizeof（LinkList））;
s->
coef=p->
r->
r=s;
p=p->
r->
next=NULL;
/*********表达式相乘******************************/
voidMulti（LinkList*LA,LinkList*LB,LinkList*&
L）
voidSimplify（LinkList*L）;
voidDispList（LinkList*L）;
voidsort_HtoL（LinkList*L）;
LinkList*p,*q,*r,*s;
L=（LinkList*）malloc（sizeof（LinkList））;
//创建头结点;
L->
next=NULL;
r=L;
p=LA->
q=LB->
while（p）
while（q）
s=（LinkList*）malloc（sizeof（LinkList））;
//创建结点;
coef=（p->
coef）*（q->
coef）;
//系数相乘;
exp=（p->
exp）+（q->
exp）;
//指数相加;
next=s;
r=s;
q=q->
q=LB->
//q重新指向LB的第一结点;
p=p->
sort_HtoL（L）;
Simplify（L）;
DispList（L）;
InitList（L）;
【测试截图】
测试用例：
表达式一:
2X^3+3X^4+4X^5+5X^6+6X^7
表达式二:
3X^3+4X^4+（-5）X^6+6X^（-2）+（-2）X^（-3）
【调试过程】
整个过程还算顺利，在确定数据接收及存储形式后主要在加法实现上花了些时间，主要问题是对链表操作不够熟练。
基本运算实现后，重点考虑了对一些特殊数据的处理，比如系数为0或为负数的情况。
【心得体会】
通过此次试验，加深了我对链表的理解，对于链表的相关操作更加熟悉，调试过程使我对整个程序结构把握更好，当整个程序完成之后，发现几乎没有什么难点，但却花了不少时间，主要问题就在于对理论知识掌握不够熟练，相关练习少，这些直接加大了题目的难度。
因此多动手操作是提高编程能力的最有效途径之一，同时我也认识到，对理论知识的掌握程度决定了能否编出个好的程序来。
实验二
——表达式求值
表达式计算是实现程序设计语言的基本问题之一，也是栈的应用的一个典型例子。
设计一个程序，演示用算符优先法对算术表达式求值的过程。
以字符序列的形式从终端输入语法正确的、不含变量的整数表达式。
利用运算符优先关系，实现对算术四则混合运算表达式的求值。
计算算术表达式的值，输出结果，及相应的后缀表达式
顺序栈；
算术表达式由键盘接收，先将中缀表达式变为后缀表达式，即通过判断运算符优先级，对相应运算符和操作数的位置作调整后入栈，同时去掉括号；
计算后缀表达式时，先读入两个操作数，将其入数值栈，再读入一个操作符，做相应运算后，再将结果入数值栈，最后数值栈中元素的值即为表达式结果注意对浮点型数据的处理。
intleftpri（charop）//求左运算符（栈内）的优先级;
intrightpri（charop）//求右运算符（栈外）的优先级;
intcomp_pri（charop1,charop2）//运算符优先级比较;
voidtrans（char*exp,charpostexp[]）//遍历中缀表达式得出后缀表达式
floatcalculate（char*postexp）//计算表达式的值
//求左运算符（栈内）的优先级;
intleftpri（charop）
inti;
for（i=0;
i<
7;
i++）
if（lpri[i].ch==op）
return（lpri[i].pri）;
//返回操作符的优先级;
return0;
//求右运算符（栈外）的优先级;
intrightpri（charop）
if（rpri[i].ch==op）
return（rpri[i].pri）;
//运算符优先级比较;
intcomp_pri（charop1,charop2）
if（leftpri（op1）==rightpri（op2））//当前运算符与栈顶运算符同级;
return0;
elseif（leftpri（op1）>
rightpri（op2））//当前运算符优先级低于栈顶运算符;
return1;
else//当前运算符优先级高于栈顶运算符;
return-1;
/******遍历中缀表达式exp***得出后缀表达式*****************/
voidtrans（char*exp,charpostexp[]）
//intcomp_pri（charop1,charop2）;
SqStack*op;
//定义操作符栈;
InitStack（op）;
//初始化操作符栈;
inti=0;
chartemp;
//退栈时的中间变量;
Push（op,'
='
）;
//先将'
进栈;
while（*exp!
='
\0'
）
if（!
IsOp（*exp））//扫描到数字字符;
while（（（*exp>
0'
）&
（*exp<
9'
））||*exp=='
.'
postexp[i++]=*exp;
//将此数存入数组;
exp++;
postexp[i++]='
#'
;
else//扫描到运算符;
Pop（op,temp）;
if（comp_pri（temp,*exp）==0）//当前扫描到的操作符与操作符栈栈顶元素同优先级;
//继续扫描其它字符;
elseif（comp_pri（temp,*exp）>
0）//栈顶元素的优先级高;
postexp[i++]=temp;
//退栈并将操作符存入数组;
else//栈顶元素的优先级低;
Push（op,temp）;
Push（op,*exp）;
//直接进临时栈;
while
（1）//exp扫描完毕,退栈直到遇到'
Pop（op,temp）;
if（temp=='
break;
postexp[i++]=temp;
postexp[i++]='
//给操作符数组添加结束标志;
/*****计算表达式的值***运算符数组***操作数数组*********/
floatcalculate（char*postexp）
struct
floatdata[MaxSize];
inttop;
}st;
floata,b,c,d,f;
st.top=-1;
while（*postexp!
switch（*postexp）
case'
+'
:
{a=st.data[st.top];
st.top--;
b=st.data[st.top];
c=a+b;
st.top++;
st.data[st.top]=c;
break;
-'
a=st.data[st.top];
c=b-a;
*'
c=a*b;
/'
if（a!
=0）
{
c=b/a;
st.top++;
st.data[st.top]=c;
}
else
printf（"
零做为被除数,错误!
"
default:
d=0;
f=0;
intflag=0,count=1;
while（（*postexp>
&
*postexp<
）||*postexp=='
if（0==flag&
*postexp!
{
d=d*10+*postexp-'
postexp++;
}
elseif（*postexp=='
flag=1;
//遇到小数点,置标记1;
elseif（1==flag）
f=f+（*postexp-'
）*pow（0.1,count）;
count++;
flag=0;
//重置标记为0;
st.data[st.top]=d+f;
break;
}
postexp++;
return（st.data[st.top]）;
【测试案例】
表达式1：
25；
表达式2：
2+3*4–5/6；
表达式3：
1024/（4*8）；
表达式4：
3–3–3；
表达式5：
（1.25*4–2/0.5）/111;
首先要做好计算表达式的前期准备，即选好存储结构，预先设置运算符的优先级，然后是对运算符优先级的比较，设计算法将中缀表达式转换为后缀表达式，最后进行求值。
几个关键点：
对运算符比较优先级之后的处理，操作数的处理，浮点数的处理在进行浮点型数据的调试之前先进行整型数据的测试。
对于逻辑上的错误或者那些隐藏较深的错误最好采用单步调试，步步跟踪变量值的改变，这样能容易对程序做出针对性的修改。
表达式求值是栈的一个经典应用实例，对于刚学完栈就进行这种小程序的编写，有一定难度，但就是这种有一定综合性的题目更能检测我们对理论知识的掌握程度。
对问题的细致分析是解决问题的关键，先得出总体解决思路，明确各个步骤后，再各个击破，考虑细节问题，当基本功能实现后，就要开始考虑功能的扩展，对特殊情况的处理方案，代码的优化，要力求达到任何一个非专业人士都能正常的运行你所编出来的程序。
实验三
——完全二叉树的判定
一棵完全二叉树的判定在纸上很容易实现，但在计算机中也如此吗？
所以设计一个计算机应用程序，实现完全二叉树的判定运算。
（1）、采用顺序表及二叉链表分别作存储结构，写出相应的算法。
（2）、要求从键盘上录入相应的二叉树的结点。
（3）、利用完全二叉树的性质及树的层次遍历实现该算法，并在屏幕上输出相应的判定结果。
1）判断由先序遍历和中续遍历序列决定的二叉树是否是完全二叉树；
2）判断由括号表达式表示的二叉树是否是完全二叉树。
i．二叉树的输入（分为括号表达式型和先序、中序型）；
ii．转换为链式存储的二叉树；
iii．判断：
1）找到第一个缺左孩子的节点；
2）缺左孩子的的结点不能有右孩子；
3）缺右孩子的结点，后续结点不能有孩子；
4）左、右孩子都缺的结点，后续结点不能有孩子；
iv．借助队列，临时存储结点。
/*pre存放先序序列,in存放中序序列,n为二叉树结点个数*/
BTNode*CreatBT（char*pre,char*in,intn）
/*********用括号表示法创建二叉树**********/
voidCreatBTNode（BTNode*&
BTree,char*str）
/***完全二叉树的判定****/
intIsFullBT（BTNode*T）
【算法实现】
/*****************二叉树的创建**************************/
BTNode*s;
char*p;
intk;
if（n<
=0）
returnNULL;
s=（BTNode*）malloc（sizeof（BTNode））;
//创建二叉树结点;
s->
data=*pre;
//根节点;
for（p=in;
p<
in+n;
p++）//pre指向根节点;
if（*p==*pre）
//找到后退出;
k=p-in;
//确定根节点在in中的位置;
lchild=CreatBT（pre+1,in,k）;
//递归构造左子树;
rchild=CreatBT（pre+k+1,p+1,n-k-1）;
//递归构造右子树;
returns;
BTNode*st[MaxSize];
//双亲结点栈;
BTNode*p;
inttop=-1,k,j=0;
charch;
BTree=NULL;
ch=str[j];
while（ch!
switch（ch）
（'
top++;
st[top]=p;
k=1;
//左孩子结点;
）'
top--;
'
k=2;
//右孩子结点;
default:
p=（BTNode*）malloc（sizeof（BTNode））;
data=ch;
lchild=p->
rchild=NULL;
if（BTree==NULL）
BTree=p;
升级会员 