《数据结构》实训报告.docx
《《数据结构》实训报告.docx》由会员分享，可在线阅读，更多相关《《数据结构》实训报告.docx（21页珍藏版）》请在冰豆网上搜索。
《数据结构》实训报告
实验一线性表
1.实验要求
1.1掌握数据结构中线性表的基本概念。
1.2熟练掌握线性表的基本操作：
创建、插入、删除、查找、输出、求长度及合并并运算在顺序存储结构上的实验。
1.3熟练掌握链表的各种操作和应用。
2.实验内容
2.1编写一个函数，从一个给定的顺序表A中删除元素值在x到y之间的所有元素，要求以较高效率来实现。
2.2试写一个算法，在无头结点的动态单链表上实现线性表插入操作
2.3设计一个统计选票的算法，输出每个候选人的得票结果。
3.实验代码
2.1代码：
#include
typedefintelemtype;
#definemaxsize10
intdel（intA[],intn,elemtypex,elemtypey）
{
inti=0,k=0;
while（i{if（A[i]>=x&&A[i]<=y）
k++;
else
A[i-k]=A[i];
i++;
}
return（n-k）;
}
voidmain（）
{
inti,j;
inta[maxsize];
Printf（"输入％d个数:
∖n",maxsize）;
for（i=0;iscanf（"%d,",&a[i]）;
j=del（a,maxsize,1,3）;
Printf（"输出删除后剩下的数:
∖n"）;
for（i=0;iPrintf（"%d"∖n,a[i]）;
}
2.2代码：
INSERT（L,i,b）。
voidInSert（Linklist&L,inti,elemtypex）
{
if（!
L）
{
L=（Linklist）malloc（sizeof（Lnode））;
（*L）.data=x;（*L）.next=NULL;
}
else
{
if（i==1）
{
S=（Linklist）malloc（sizeof（Lnode））;s->data=x;S->next=L;L=s;
}
else
{
P=L;j=1;
WhiIe（P&&j{j++;P=P->next;}
if（p∣∣j>i-1）returnerror;
S=（Linklist）malloc（sizeof（Lnode））;s->data=x;S->next=p->next;P->next=s;
}
}
}
2.3代码：
typedefintelemtype
typedefStrUCtIinknOde
{
elemtypedata;
StrUCtIinknOde*next;
}nodetype;
nodetype*create（）
{
elemtyped;
nOdetyPeh=NULL,*s,*t;
inti=1;
Printf（"建立单链表:
∖n"）;
while
（1）
{
Printf（"输入第%d个结点数据域",i）;
SCanf（"%d",&d）;
if（d==O）break;
if（i==1）
{
h=（nodetype*）malloc（sizeof（nodetype））;h->data=d;h->next=NULL;t=h;
}
else
{
s=（nodetype*）malloc（sizeof（nodetype））;s->data=d;S->next=NULL;t->next=s;t=s;
}
i++;
}
returnh;
}
voidSat（nodetype*h,inta[]）
{
nodetype*p=h;
WhiIe（P!
=NULL）
{
a[p->data]++;
P=P->next;
}
}
voidmain（）
{
inta[N+1],i;
for（i=0;ia[i]=0;
nodetype*head;
head=create（）;
sat（head,a）;
Printf（"候选人:
"）；for（i=1;i<=N;i++）Printf（"%3d",i）;Printf（"∖n得票数∖n"）;
for（i=1;i<=N;i++）
Printf（"%3d",a[i]）;
Printf（"∖n"）;
}
4.实验小结
线性表是最简单的、最常用的一种数据结构，是实现其他数据结构的基础
实验二栈与队列
1.实验要求
1.1了解栈和队列的特性，以便灵活运用。
1.2熟练掌握栈和有关队列的各种操作和应用。
2.实验内容
2.1设一个算术表达式包括圆括号，方括号和花括号三种括号，编写一个算法判断其中的括号是否匹配。
3.实验代码
2.1代码：
#include
#include
#include
#defineNULL0
typedefStrUCtlist
{
Charstr;
StrUCtlist*next;
}list;
voidPUSh（Char,list*）;
intPOP（Char.list*）;
voiddeal（char*str）;
main（void）
{
Charstr[20];
Printf（"\n请输入一个算式:
\n"）;
gets（str）;
deal（str）;
Printf（"正确!
"）;
getchar（）;
return0;
}
voiddeal（char*str）
{
list*L;
L=（IiSt*）malloc（sizeof（list））;
if（!
L）
{
Printf（"错误!
"）;
exit（-2）;
}
L->next=NULL;
while（*str）
{
if（*str=='（'∣∣*str=='['∣∣*str=='{'）push（*str,L）;
else
if（*str=='）'∣∣*str==']'∣∣*str=='}'）if（pop（*str,L））{puts（"错误请检查!
"）;puts（"按回车键退出"）;getchar（）;exit（-2）;
}
sM++;
}
if（L->next）
{
PUtSe错误,请检查!
"）;
puts（"按任意键退出"）;
getchar（）;exit（-2）;
}
}
voidPUSh（Charc,list*L）
{
list*p;
P=（IiSt*）malloc（sizeof（list））;
if（!
p）
{
Printf（"错误!
"）;
exit（-2）;
}
p->str=c;
p->next=L->next;
L->next=p;
}
#defineCheCk（S）if（L->next->str==s）{p=l->next;L->next=p->next;free（p）;return（0）;}intPOP（Charc,list*L）
{
list*p;
if（L->next==NULL）return1;
SWitCh（C）
{
case'）':
check（'（'）break;
CaSe']':
CheCk（T）break;
case'}':
check（'{'）break;
}
return1;
4.实验小结
栈和队列是最基础的一种数据结构之一，为实现其他数据结构的奠定基石
实验三树
1.实验要求
1.1掌握二叉树，二叉树排序数的概念和存储方法。
1.2掌握二叉树的遍历算法。
1.3熟练掌握编写实现树的各种运算的算法。
2.实验内容
2.1编写程序，求二叉树的结点数和叶子数。
2.2编写递归算法，求二叉树中以元素值为X的结点为根的子数的深度
2.3编写程序，实现二叉树的先序，中序，后序遍历，并求其深度。
3.实验代码
2.1代码：
#include
#include
StrUCtnode{
Chardata;
StrUCtnode*lchild,*rchild;
}bnode;
typedefStrUCtnode*blink;
blinkCreatO
{
blinkbt;
Charch;
ch=getchar（）;
if（ch==''）return（NULL）;
else
{
bt=（structnode*）malloc（sizeof（bnode））;bt->data=ch;
bt->lchild=creat（）;
bt->rchild=creat（）;
}
returnbt;
}
intn=0,n1=0;
voidPreOrder（blinkbt）
{
if（bt）
{
n++;
if（bt->lchild==NULL&&bt->rchild==NULL）n1++;
PreOrder（bt->lchild）;
PreOrder（bt->rchild）;
}
}
voidmain（）
{
blinkroot;
root=creat（）;
PreOrder（root）;
Printf（"此二叉数的接点数有:
%d\n",n）;
Printf（"此二叉数的叶子数有:
%d\n",n1）;}
2.2代码：
intget_deep（bitreeT,intx）
{_
if（T->data==x）
{
Printf（"%d\n",get_deep（T））;exit1;
}
else
{
if（T->lchild）get_deep（T->lchild,x）;if（T->rchild）get_deep（T->rchild,x）;
}_
intget_depth（bitreeT）
{_
if（!
T）return0;
else
{m=get_depth（T->lchild）;n=get_depth（T->rchild）;
return（m>n?
m:
n）+1;
}
}
2.3代码：
#include
#include
StrUCtnode{
Chardata;
StrUCtnode*lchild,*rchild;
}bnode;
typedefStrUCtnode*blink;
blinkCreato
{
blinkbt;
Charch;
ch=getchar（）;
if（ch==''）return（NULL）;
else
{
bt=（structnode*）malloc（sizeof（bnode））;bt->data=ch;
bt->lchild=creat（）;
bt->rchild=creat（）;
}
returnbt;
}
voidPreOrder（blinkbt）
{
if（bt）
{
Printf（"%c",bt->data）;
PreOrder（bt->lchild）;
PreOrder（bt->rchild）;
}
}
voidinorder（blinkbt）
{
if（bt）
{
inorder（bt->lchild）;
Printf（"%c",bt->data）;
inorder（bt->rchild）;
}
}
voidpostorder（blinkbt）
{
if（bt）
{
postorder（bt->lchild）;
postorder（bt->rchild）;
Printf（"%c",bt->data）;
}
}
intmax（intx,inty）
{
if（x>y）
returnx;
else
returny;
}
intdepth（blinkbt）
{
if（bt）
return1+max（depth（bt->lchild）,depth（bt->rchild））;
elsereturn0;
}
VOidmain（）
{
blinkroot;
root=creat（）;
Printf（"∖n"）;
Printf（"按先序排列:
"）;
PreOrder（root）;Printf（"∖n"）;
Printf（"按中序排列:
"）;
inorder（root）;Printf（"∖n"）;
Printf（"按后序排列:
"）;
Postorder（root）;Printf（"∖n"）;
Printf（"此二叉数的深度是:
"）;
Printf（"depth=%d∖n",depth（root））;
}
4.实验小结
通过本章学习实验，对树有了初步的认识。
树就是一种非线性的数据结构，描述了客观世界中事物之间的层次关系。
这种结构有着广泛的应用，一切具有层次关系的问题都可以用树来表示。
实验四图
1.实验要求
1.1熟悉图的各种存储方法。
1.2掌握遍历图的递归和非递归的算法。
1.3理解图的有关算法。
2.实验内容
2.1写出将一个无向图的邻接矩阵转换成邻接表的算法
2.2以邻接表作存储结构，给出拓扑排序算法的实现。
3.实验代码
2.1代码：
VOidmattolist（inta[][],adjlistb[],intn）/*n为图的结点个数*/
{
for（i=0;ifor（i=0;ifor（j=n-1;j>=0;j--）
if（a[i][j]!
=0）
{p=（arcnodetp*）malloc（sizeof（arcnodetp））;/*产生邻接点*/p->adjvex=j;
p->nextare=b[i].firstare;
b[i].firstarc=p;
}
}
2.2代码：
typedefStrUCtVeXnode
{
VerteXTyPevertex;
intin;/*增加一个入度域*/
AreCNOdeTP*fristarc;
}AdjList[vnum];
typedefStrUCtgraph
{
AdjLiStadjlist;
intVeXnum,arcnum;
}GraphTp;
Top_SOrt（GraPhTPg）
{
LStaCkTP*p;/*建立入度为O的顶点栈S*/
intm,i,v;
initStack（S）;
for（i=0;iif（g.adjlist[i].in==0）∕*if（w的入度==0）*/
PuSh（S,&v）;/*W入S栈*/
m=0;
whlie（!
EmptyStack（S））{
Pop（S,&v）〃S出栈->v
Printf（"%d",v）;/*输出v*/
m++;
p=g.adjlist[i].fristarc;/*P=图g中顶点V的第一个邻接点*/
WhiIe（P!
=NULL）{//p存在
（g.adjlist[p->adjvex].in）--;/*P的入度--*/if（g.adjlist[p->adjvex].in==0）∕*if（p的入度==0）*/
PUSh（S,p->adjvex）;/*P入S栈*/
p=p->nextarc;/*P=图g中的顶点V的下一个邻接点*/
}
}
if（melsereturn1;
}
4.实验小结
通过本章学习实验，对图有了具体的认识。
图也是一种非线性的数据结构,这种结构有着广泛的应用，一切具有关系的问题都可以用图来表示。
实验五查找
1.实验要求
1.1掌握顺序查找、二分法查找、分块查找和哈希表查找的算法。
1.2能运用线性表的查找方法解决实际问题。
2.实验内容
2.1编写一个算法，利用二分查找算法在一个有序表中插入一个元素
X,并保持表的有序性。
2.2根据给定的数据表，先建立索引表，然后进行分块查找。
3.实验代码
2.1代码：
#includeVStdiO.h>
#includeVString.h>
#defineMAXNUM20
intinput（int*）;/*输入数据*/
intSearCh（int*,int,int）;/*查找插入位置*/
voidplug（int*,int,int）;/*插入数据*/
voidmain（VOid）
{
intdata[MAXNUM],m;
intinSert=1;
m=input（data）;
Printf（"InputtheinSertnum:
"）;
SCanf（"%d",data）;
inSert=SearCh（data,1,m）;/*返回插入位置*/
plug（data,insert,m）;
for（insert=1;insert<=m+1;insert++）/*显示数据*/
Printf（"%3d",*（data+insert））;
getch（）;
}
intinput（int*data）
{
inti,m;
Printf（"∖nlnPUtthemaxnum:
"）;
SCanf（"%d",&m）;
Printf（"inputdata\n"）;
for（i=1;i<=m;i++）
SCanf（"%d",data+i）;
returnm;
}
intSearCh（int*data,intlow,inthigh）/*递归查找插入位置*/
{
intmid;
if（low>high）returnlow;/*没有找到插入数据，返回low*/else{
mid*/
mid=（low+high）∕2;
if（*（data+mid）==*data）retunmid;/*找到插入数据，返回
elseif（*（data+mid）<*data）
elseif（*（）data+mid）>*data）
}
SearCh（data,low,high）;
}
voidplug（int*data,intinsert,intm）
{
inti;
for（i=m;i>insert;i--）
*（data+i+1）=*（data+i）;
（data+inSert）=*data
}
2.2代码：
#includeVStdiO.h>
#ineludeVCOnio.h>
#include
#definrN18/*元素个数*/
#definrBlocknum3/*分块数*/
typedefStrUCtindexterm
{
intkey;/*最大关键字*/
intaddr;/*块的起始地址*/
}index;/*索引表数据类型*/
index*CreateList（intdata[],intn）/*建索引表*/
{
index*p;
intm,j,k;
m=n/BlockNum;/*分为BlockNum块，每块有m个元素*/
p=（index*）malloc（BlockNum*sizeof（index））;
for（k=O;k（p+k）->key=data[m*k];
（p+k）->addr=m*k;
for（j=m*k;jif（data[j]>（p+k）->key）
（p+k）->key=data[j];/*块的最大关键字*/
}
returnp;
}
intBlockSearch（index*list,intrectab[],intn,intm,intk）/*分块查找*/
{
intlow=0,high=m-1,mid,i;
intb=n/m;/*每块有b个元素*/
WhiIe（IOWV=high）{∕*块间折半查找*/
mid=（low+high）∕2;
if（（list+mid）->key>=k）
high=mid+1;
elselow=mid+1;
}
if（lowfor（i=（list+low）->addr;i<=（list+low）->adder+b-1&&rectab[i]!
=k;i++）;
if（i<=（list+low）->addr+b-1）
returni;
elsereturn-1;
}
return-1;
}
voidmain（）
{
intrecord[N]={22,12,13,8,9,20,33,42,44,38,24,48,60,58,74,49,86,53};
intkey;
index*list;
Printf（"pleaseinPUtkey:
\n"）;
SCanf（"%d",&key）;
IiSt=CreateLiSt（record,N）;
Printf（"datapostionid%d∖n",BlockSearch（list,record,N,BlockNum,key））;
}
4.实验小结
通过本章的学习，对排序有较高层次的理解与认识，从平时的练习中可以看出排序是数据处理中经常用到的重要运算。
有序的顺序表可以采用查找效率较高的折半查找法，而无序的顺序表只能用效率较低的顺序查找法。
升级会员 