数据结构实验报告答案Word文件下载.docx
《数据结构实验报告答案Word文件下载.docx》由会员分享，可在线阅读，更多相关《数据结构实验报告答案Word文件下载.docx（34页珍藏版）》请在冰豆网上搜索。
//修改程序：
增加节点。
用头插法，返回头指针
//==========主函数==============
voidmain（）
charch[10],num[5];
LinkListhead;
head=CreatList（）;
//用头插入法建立单链表，返回头指针
printlist（head）;
//遍历链表输出其值
printf（"
Deletenode（y/n）:
"
）;
//输入"
y"
或"
n"
去选择是否删除结点
scanf（"
%s"
num）;
if（strcmp（num,"
）==0||strcmp（num,"
Y"
）==0）{
printf（"
PleaseinputDelete_data:
scanf（"
ch）;
//输入要删除的字符串
DeleteList（head,ch）;
printlist（head）;
}
Addnode?
（y/n）:
去选择是否增加结点
）==0）
head=AddNode（head）;
DeleteAll（head）;
//删除所有结点，释放存
}
//==========用尾插入法建立带头结点的单链表===========
LinkListCreatListR1（void）
charch[10];
LinkListhead=（LinkList）malloc（sizeof（ListNode））;
//生成头结点
ListNode*s,*r,*pp;
r=head;
r->
next=NULL;
Input#toend"
#"
代表输入结束
\nPleaseinputNode_data:
//输入各结点的字符串
while（strcmp（ch,"
）!
=0）{
pp=LocateNode（head,ch）;
//按值查找结点，返回结点指针
if（pp==NULL）{//没有重复的字符串，插入到链表中
s=（ListNode*）malloc（sizeof（ListNode））;
strcpy（s->
data,ch）;
r->
next=s;
r=s;
}
printf（"
PleaseinputNode_data:
returnhead;
//返回头指针
//==========用头插入法建立带头结点的单链表===========
LinkListCreatList（void）
charch[100];
LinkListhead,p;
head=（LinkList）malloc（sizeof（ListNode））;
head->
while
（1）
{
if（strcmp（ch,"
））
{
if（LocateNode（head,ch）==NULL）
{
strcpy（head->
p=（LinkList）malloc（sizeof（ListNode））;
p->
next=head;
head=p;
}
else
break;
//==========按值查找结点，找到则返回该结点的位置，否则返回NULL==========
ListNode*LocateNode（LinkListhead,char*key）
ListNode*p=head->
next;
//从开始结点比较
while（p!
=NULL&
&
strcmp（p->
data,key）!
=0）//直到p为NULL或p->
data为key止
p=p->
//扫描下一个结点
returnp;
//若p=NULL则查找失败，否则p指向找到的值为key的结点
//==========修改程序：
增加节点=======
ListNode*AddNode（LinkListhead）
ListNode*s,*pp;
\nPleaseinputaNewNode_data:
pp=LocateNode（head,ch）;
ok2\n"
if（pp==NULL）{//没有重复的字符串，插入到链表中
s=（ListNode*）malloc（sizeof（ListNode））;
strcpy（s->
ok3\n"
s->
next=head->
head->
//==========删除带头结点的单链表中的指定结点=======
voidDeleteList（LinkListhead,char*key）
ListNode*p,*r,*q=head;
p=LocateNode（head,key）;
//按key值查找结点的
if（p==NULL）{//若没有找到结点，退出
positionerror"
exit（0）;
while（q->
next!
=p）//p为要删除的结点，q为p的前结点
q=q->
r=q->
q->
next=r->
free（r）;
//释放结点
//===========打印链表=======
voidprintlist（LinkListhead）
//从开始结点打印
while（p）{
%s,"
p->
data）;
\n"
//==========删除所有结点，释放空间===========
voidDeleteAll（LinkListhead）
ListNode*p=head,*r;
while（p->
next）{
r=p->
free（p）;
p=r;
free（p）;
实验结果：
Input#toendPleaseinputNode_data:
bat
cat
eat
fat
hat
jat
lat
mat
#
mat,lat,jat,hat,fat,eat,cat,bat,
y
mat,lat,jat,fat,eat,cat,bat,
Insertnode（y/n）:
PleaseinputInsert_data:
put
position:
5
mat,lat,jat,fat,eat,put,cat,bat,
请按任意键继续...
示意图：
心得体会：
本次实验使我们对链表的实质了解更加明确了，对链表的一些基本操作也更加熟练了。
另外实验指导书上给出的代码是有一些问题的，这使我们认识到实验过程中不能想当然的直接编译执行，应当在阅读并完全理解代码的基础上再执行，这才是实验的意义所在。
实验2
二叉树操作设计和实现
掌握二叉树的定义、性质及存储方式，各种遍历算法。
采用二叉树链表作为存储结构，完成二叉树的建立，先序、中序和后序以及按层次遍历的操作，求所有叶子及结点总数的操作。
1、分析、理解程序。
2、调试程序，设计一棵二叉树，输入完全二叉树的先序序列，用#代表虚结点（空指针），如ABD###CE##F##，建立二叉树，求出先序、中序和后序以及按层次遍历序列，求所有叶子及结点总数。
实验代码
#defineMax20//结点的最大个数
typedefstructnode{
chardata;
structnode*lchild,*rchild;
}BinTNode;
//自定义二叉树的结点类型
typedefBinTNode*BinTree;
//定义二叉树的指针
intNodeNum,leaf;
//NodeNum为结点数，leaf为叶子数
//==========基于先序遍历算法创建二叉树==============
//=====要求输入先序序列，其中加入虚结点"
以示空指针的位置==========
BinTreeCreatBinTree（void）
BinTreeT;
charch;
if（（ch=getchar（））=='
#'
）
return（NULL）;
//读入#，返回空指针
else{
T=（BinTNode*）malloc（sizeof（BinTNode））;
//生成结点
T->
data=ch;
lchild=CreatBinTree（）;
//构造左子树
T->
rchild=CreatBinTree（）;
//构造右子树
return（T）;
//========NLR先序遍历=============
voidPreorder（BinTreeT）
if（T）{
%c"
T->
//访问结点
Preorder（T->
lchild）;
//先序遍历左子树
rchild）;
//先序遍历右子树
//========LNR中序遍历===============
voidInorder（BinTreeT）
Inorder（T->
//中序遍历左子树
//中序遍历右子树
//==========LRN后序遍历============
voidPostorder（BinTreeT）
Postorder（T->
//后序遍历左子树
Postorder（T->
//后序遍历右子树
//=====采用后序遍历求二叉树的深度、结点数及叶子数的递归算法========
intTreeDepth（BinTreeT）
inthl,hr,max;
if（T）{
hl=TreeDepth（T->
//求左深度
hr=TreeDepth（T->
//求右深度
max=hl>
hr?
hl:
hr;
//取左右深度的最大值
NodeNum=NodeNum+1;
//求结点数
if（hl==0&
hr==0）leaf=leaf+1;
//若左右深度为0，即为叶子。
return（max+1）;
elsereturn（0）;
//====利用"
先进先出"
（FIFO）队列，按层次遍历二叉树==========
voidLevelorder（BinTreeT）
intfront=0,rear=1;
BinTNode*cq[Max],*p;
//定义结点的指针数组cq
cq[1]=T;
//根入队
while（front!
=rear）
front=（front+1）%NodeNum;
p=cq[front];
//出队
//出队，输出结点的值
if（p->
lchild!
=NULL）{
rear=（rear+1）%NodeNum;
cq[rear]=p->
lchild;
//左子树入队
rchild!
rchild;
//右子树入队
//====数叶子节点个数==========
intcountleaf（BinTreeT）
inthl,hr;
hl=countleaf（T->
hr=countleaf（T->
hr==0）//若左右深度为0，即为叶子。
return
（1）;
elsereturnhl+hr;
elsereturn0;
//==========主函数=================
BinTreeroot;
chari;
intdepth;
CreatBin_Tree；
Inputpreorder:
//输入完全二叉树的先序序列，
//用#代表虚结点，如ABD###CE##F##
root=CreatBinTree（）;
//创建二叉树，返回根结点
do{//从菜单中选择遍历方式，输入序号。
\t**********select************\n"
\t1:
PreorderTraversal\n"
\t2:
IorderTraversal\n"
\t3:
Postordertraversal\n"
\t4:
PostTreeDepth,Nodenumber,Leafnumber\n"
\t5:
LevelDepth\n"
//按层次遍历之前，先选择4，求出该树的结点数。
\t0:
Exit\n"
\t*******************************\n"
fflush（stdin）;
&
i）;
//输入菜单序号（0-5）
switch（i-'
0'
）{
case1:
PrintBin_treePreorder:
"
Preorder（root）;
//先序遍历
break;
case2:
PrintBin_TreeInorder:
Inorder（root）;
//中序遍历
break;
case3:
PrintBin_TreePostorder:
Postorder（root）;
//后序遍历
case4:
depth=TreeDepth（root）;
//求树的深度及叶子数
BinTreeDepth=%dBinTreeNodenumber=%d"
depth,NodeNum）;
BinTreeLeafnumber=%d"
countleaf（root））;
case5:
LevePrintBin_Tree:
Levelorder（root）;
//按层次遍历
default:
exit
（1）;
}while（i!
=0）;
}
ABD###CE##F##
**********select************
1:
PreorderTraversal
2:
IorderTraversal
3:
Postordertraversal
4:
PostTreeDepth,Nodenumber,Leafnumber
5:
LevelDepth
0:
Exit
*******************************
1
ABDCEF
2
DBAECF
3
DBEFCA
4
BinTreeDepth=3BinTreeNodenumber=6BinTreeLeafnumber=3
5
ABCDEF
0
Pressanykeytocontinue
二叉树示意图
这次实验加深了我对二叉树的印象，尤其是对二叉树的各种遍历操作有了一定的了解。
同时认识到，在设计程序时辅以图形化的描述是非常有用处的。
实验3
图的遍历操作
掌握有向图和无向图的概念；
掌握邻接矩阵和邻接链表建立图的存储结构；
掌握DFS及BFS对图的遍历操作；
了解图结构在人工智能、工程等领域的广泛应用。
采用邻接矩阵和邻接链表作为图的存储结构，完成有向图和无向图的DFS和BFS操作。
设计一个有向图和一个无向图，任选一种存储结构，完成有向图和无向图的DFS（深度优先遍历）和BFS（广度优先遍历）的操作。
1．邻接矩阵作为存储结构
#defineMaxVertexNum100//定义最大顶点数
typedefstruct{
charvexs[MaxVertexNum];
//顶点表
intedges[MaxVertexNum][MaxVertexNum];
//邻接矩阵，可看作边表
intn,e;
//图中的顶点数n和边数e
}MGraph;
//用邻接矩阵表示的图的类型
//=========建立邻接矩阵=======
voidCreatMGraph（MGraph*G）
inti,j,k;
chara;
InputVertexNum（n）andEdgesNum（e）:
%d,%d"
G->
n,&
e）;
//输入顶点数和边数
a）;
InputVertexstring:
for（i=0;
i<
n;
i++）
G->
vexs[i]=a;
//读入顶点信息，建立顶点表
i++）
for（j=0;
j<
j++）
G->
edges[i][j]=0;
//初始化邻接矩阵
Inputedges,CreatAdjacencyMatrix\n"
for（k=0;
k<
e;
k++）{//读入e条边，建立邻接矩阵
%d%d"
i,&
j）;
//输入边（Vi，Vj）的顶点序号
edges[i][j]=1;
升级会员 