《数据结构》实训报告.docx
《《数据结构》实训报告.docx》由会员分享，可在线阅读，更多相关《《数据结构》实训报告.docx（25页珍藏版）》请在冰豆网上搜索。
《数据结构》实训报告
实验一线性表
1.实验要求
1.1掌握数据构造中线性表的基本观点。
1.2娴熟掌握线性表的基本操作：
创立、插入、删除、查找、输出、求长度
及归并并运算在次序储存构造上的实验。
1.3娴熟掌握链表的各样操作和应用。
2.实验内容
2.1编写一个函数，从一个给定的次序表A中删除元素值在x到y之间的所
有元素，要求以较高效率来实现。
2.2试写一个算法，在无头结点的动向单链表上实现线性表插入操作
2.3设计一个统计选票的算法，输出每个候选人的得票结果。
3.实验代码
代码：
#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]）;
}
代码：
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;
while（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;
}
}
}
代码：
typedefintelemtype
typedefstructlinknode
{
elemtypedata;
structlinknode*next;
}nodetype;
nodetype*create（）
{
elemtyped;
nodetypeh=NULL,*s,*t;
inti=1;
printf（"成立单链表:
\n"）;
while
（1）
{
printf（"输入第%d个结点数据域",i）;
scanf（"%d",&d）;
if（d==0）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;
while（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.
2.
3.
实验要求
1.1认识栈和行列的特征，以便灵巧运用。
1.2娴熟掌握栈和相关行列的各样操作和应用。
实验内容
2.1设一个算术表达式包含圆括号，方括号和花括号三种括号，编写一个算
法判断此中的括号能否般配。
实验代码
代码：
#include<>
#include<>
#include<>
#defineNULL0
typedefstructlist
{
charstr;
structlist*next;
}list;
voidpush（char,list*）;
intpop*）;
voiddeal（char*str）;
main（void）
{
charstr[20];
printf（"\n请输入一个算式:
\n"）;
gets（str）;
deal（str）;
printf（"正确!
"）;
getchar（）;
return0;
}
voiddeal（char*str）
{
list*L;
L=（list*）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）;
}
str++;
}
if（L->next）
{
puts（"错误,请检查!
"）;
puts（"按随意键退出"）;
getchar（）;exit（-2）;
}
}
voidpush（charc,list*L）
{
list*p;
p=（list*）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（'['）break;
case'}':
check（'{'）break;
}
return1;
4.实验小结
栈和行列是最基础的一种数据构造之一，为实现其余数据构造的确立基石。
实验三树
1.实验要求
1.1掌握二叉树，二叉树排序数的观点和储存方法。
1.2掌握二叉树的遍历算法。
1.3娴熟掌握编写实现树的各样运算的算法。
2.实验内容
2.1编写程序，求二叉树的结点数和叶子数。
2.2编写递归算法，求二叉树中以元素值为X的结点为根的子数的深度。
2.3编写程序，实现二叉树的先序，中序，后序遍历，并求其深度。
3.实验代码
代码：
#include<>
#include<>
structnode{
chardata;
structnode*lchild,*rchild;
}bnode;
typedefstructnode*blink;
blinkcreat（）
{
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）;}
代码：
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>nm:
n）+1;
}
}
代码：
#include<>
#include<>
structnode{
chardata;
structnode*lchild,*rchild;
}bnode;
typedefstructnode*blink;
blinkcreat（）
{
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））;
else
return0;
}
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.实验代码
代码：
voidmattolist（inta[][],adjlistb[],intn）
/*n
为图的结点个数
*/
{
for（i=0;i/*
毗邻表置空*/
/*逐前进行*/
for（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;
}
}
代码：
typedefstructvexnode
{
VertexTypevertex;
intin;/*增添一个入度域*/
ArecNodeTp*fristarc;
}AdjList[vnum];
typedefstructgraph
{
AdjListadjlist;
intvexnum,arcnum;
}GraphTp;
Top_Sort（GraphTpg）
{
LstackTp*p;/*成立入度为0的极点栈S*/
intm,i,v;
initStack（S）;
for（i=0;i<;i++）
if[i].in==0）/*if（w的入度==0）*/
push（S,&v）;/*w入S栈*/
m=0;
whlie（!
EmptyStack（S））{
Pop（S,&v）ristarc;/*p=图g中极点v的第一个毗邻点*/while（p!
=NULL）{n）--;/*p的入度--*/
if[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.实验代码
代码：
#include<>
#include<>
#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（"\nInputthemaxnum:
"）;
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=（low+high）/2;
if（*（data+mid）==*data）retunmid;/*找到插入数据，返回mid*/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
}
代码：
#include<>
#include<>
#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=0;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个元素*/
while（low<=high）{/*块间折半查找*/
mid=（low+high）/2;
if（（list+mid）->key>=k）
high=mid+1;
elselow=mid+1;
}
if（lowaddr;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）;
list=CreateList（record,N）;
printf（"datapostionid%d\n",BlockSearch（list,record,N,BlockNum,key））;
}
4.实验小结
经过本章的学习，对排序有较高层次的理解与认识，从平常的练习中能够
看出排序是数据办理中常常用到的重要运算。
有序的次序表能够采纳查找
效率较高的折半查找法，而无序的次序表只好用效率较低的次序查找法。
升级会员 