实验一 线性表实训报告Word文档下载推荐.docx
《实验一 线性表实训报告Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《实验一 线性表实训报告Word文档下载推荐.docx（19页珍藏版）》请在冰豆网上搜索。
）;
j;
%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;
if（i==1）
{
s=（Linklist）malloc（sizeof（Lnode））;
s->
data=x;
s->
next=L;
L=s;
}
else
p=L;
j=1;
while（p&
j<
i-1）
{j++;
p=p->
next;
if（p||j>
returnerror;
next=p->
p->
next=s;
2.3代码：
typedefintelemtype
typedefstructlinknode
elemtypedata;
structlinknode*next;
}nodetype;
nodetype*create（）
elemtyped;
nodetypeh=NULL,*s,*t;
inti=1;
建立单链表:
while
（1）
printf（"
输入第%d个结点数据域"
i）;
%d"
d）;
if（d==0）break;
h=（nodetype*）malloc（sizeof（nodetype））;
h->
data=d;
h->
next=NULL;
t=h;
s=（nodetype*）malloc（sizeof（nodetype））;
t->
t=s;
i++;
returnh;
voidsat（nodetype*h,inta[]）
nodetype*p=h;
while（p!
=NULL）
a[p->
data]++;
p=p->
inta[N+1],i;
N;
a[i]=0;
nodetype*head;
head=create（）;
sat（head,a）;
候选人:
"
for（i=1;
=N;
i++）printf（"
%3d"
\n得票数\n"
a[i]）;
4.实验小结
线性表是最简单的、最常用的一种数据结构，是实现其他数据结构的基础。
实验二栈与队列
1.1了解栈和队列的特性，以便灵活运用。
1.2熟练掌握栈和有关队列的各种操作和应用。
2.1设一个算术表达式包括圆括号，方括号和花括号三种括号，编写一个算法判断其中的括号是否匹配。
malloc.h>
string.h>
#defineNULL0
typedefstructlist
charstr;
structlist*next;
}list;
voidpush（char,list*）;
intpop（char.list*）;
voiddeal（char*str）;
main（void）
charstr[20];
printf（"
\n请输入一个算式:
gets（str）;
deal（str）;
正确!
getchar（）;
return0;
voiddeal（char*str）
list*L;
L=（list*）malloc（sizeof（list））;
if（!
错误!
exit（-2）;
L->
while（*str）
if（*str=='
（'
||*str=='
['
{'
）
push（*str,L）;
if（*str=='
）'
]'
}'
if（pop（*str,L））
{puts（"
错误,请检查!
puts（"
按回车键退出"
getchar（）;
exit（-2）;
}
str++;
if（L->
next）
puts（"
按任意键退出"
voidpush（charc,list*L）
list*p;
p=（list*）malloc（sizeof（list））;
p）
str=c;
next=L->
next=p;
#definecheck（s）if（L->
next->
str==s）{p=l->
free（p）;
return（0）;
intpop（charc,list*L）
list*p;
if（L->
next==NULL）return1;
switch（c）
case'
:
check（'
）break;
return1;
栈和队列是最基础的一种数据结构之一，为实现其他数据结构的奠定基石。
实验三树
1.1掌握二叉树，二叉树排序数的概念和存储方法。
1.2掌握二叉树的遍历算法。
1.3熟练掌握编写实现树的各种运算的算法。
2.1编写程序，求二叉树的结点数和叶子数。
2.2编写递归算法，求二叉树中以元素值为X的结点为根的子数的深度。
2.3编写程序，实现二叉树的先序，中序，后序遍历，并求其深度。
structnode{
chardata;
structnode*lchild,*rchild;
}bnode;
typedefstructnode*blink;
blinkcreat（）
blinkbt;
charch;
ch=getchar（）;
if（ch=='
'
）return（NULL）;
bt=（structnode*）malloc（sizeof（bnode））;
bt->
data=ch;
lchild=creat（）;
rchild=creat（）;
returnbt;
intn=0,n1=0;
voidpreorder（blinkbt）
if（bt）
n++;
if（bt->
lchild==NULL&
bt->
rchild==NULL）
n1++;
preorder（bt->
lchild）;
rchild）;
blinkroot;
root=creat（）;
preorder（root）;
此二叉数的接点数有:
%d\n"
n）;
此二叉数的叶子数有:
n1）;
intget_deep（bitreeT,intx）
if（T->
data==x）
get_deep（T））;
exit1;
if（T->
lchild）get_deep（T->
lchild,x）;
rchild）get_deep（T->
rchild,x）;
intget_depth（bitreeT）
T）return0;
m=get_depth（T->
n=get_depth（T->
return（m>
n?
m:
n）+1;
%c"
bt->
data）;
voidinorder（blinkbt）
if（bt）
{
inorder（bt->
voidpostorder（blinkbt）
postorder（bt->
intmax（intx,inty）
if（x>
y）
returnx;
else
returny;
intdepth（blinkbt）
return1+max（depth（bt->
lchild）,depth（bt->
rchild））;
return0;
按先序排列:
preorder（root）;
按中序排列:
inorder（root）;
按后序排列:
postorder（root）;
此二叉数的深度是:
depth=%d\n"
depth（root））;
通过本章学习实验，对树有了初步的认识。
树就是一种非线性的数据结构，描述了客观世界中事物之间的层次关系。
这种结构有着广泛的应用，一切具有层次关系的问题都可以用树来表示。
实验四图
1.1熟悉图的各种存储方法。
1.2掌握遍历图的递归和非递归的算法。
1.3理解图的有关算法。
2.1写出将一个无向图的邻接矩阵转换成邻接表的算法。
2.2以邻接表作存储结构，给出拓扑排序算法的实现。
voidmattolist（inta[][],adjlistb[],intn）/*n为图的结点个数*/
n;
i++）b[i].firstarc=NULL;
/*邻接表置空*/
i++）/*逐行进行*/
for（j=n-1;
j>
=0;
j--）
if（a[i][j]!
=0）
{p=（arcnodetp*）malloc（sizeof（arcnodetp））;
/*产生邻接点*/
p->
adjvex=j;
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）;
g.vexnum;
if（g.adjlist[i].in==0）/*if（w的入度==0）*/
push（S,&
v）;
/*w入S栈*/
m=0;
whlie（!
EmptyStack（S））{
Pop（S,&
v）//S出栈->
v
printf（"
v）;
/*输出v*/
m++;
p=g.adjlist[i].fristarc;
/*p=图g中顶点v的第一个邻接点*/
while（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（m<
g.vexnum）return0;
/*图含有环*/
elsereturn1;
通过本章学习实验，对图有了具体的认识。
图也是一种非线性的数据结构，这种结构有着广泛的应用，一切具有关系的问题都可以用图来表示。
实验五查找
1.1掌握顺序查找、二分法查找、分块查找和哈希表查找的算法。
1.2能运用线性表的查找方法解决实际问题。
2.1编写一个算法，利用二分查找算法在一个有序表中插入一个元素X，并保持表的有序性。
2.2根据给定的数据表，先建立索引表，然后进行分块查找。
#include<
#defineMAXNUM20
intinput（int*）;
/*输入数据*/
intsearch（int*,int,int）;
/*查找插入位置*/
voidplug（int*,int,int）;
/*插入数据*/
voidmain（void）
intdata[MAXNUM],m;
intinsert=1;
m=input（data）;
Inputtheinsertnum:
scanf（"
data）;
insert=search（data,1,m）;
/*返回插入位置*/
plug（data,insert,m）;
for（insert=1;
insert<
=m+1;
insert++）/*显示数据*/
*（data+insert））;
getch（）;
intinput（int*data）
inti,m;
\nInputthemaxnum:
scanf（"
m）;
inputdata\n"
for（i=1;
=m;
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）>
search（data,low,high）;
voidplug（int*data,intinsert,intm）
inti;
for（i=m;
i>
insert;
i--）
*（data+i+1）=*（data+i）;
*（data+insert）=*data
conio.h>
#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<
BlockNum;
k++）{
（p+k）->
key=data[m*k];
addr=m*k;
for（j=m*k;
m*k+m;
j++）
if（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）{/*块间折半查找*/
if（（list+mid）->
key>
=k）
high=mid+1;
elselow=mid+1;
if（low<
m）{/*索引表申请成功后，块内顺序查找*/
for（i=（list+low）->
addr;
=（list+low）->
adder+b-1&
rectab[i]!
=k;
i++）;
if（i<
addr+b-1）
returni;
elsereturn-1;
return-1;
intrecord[N]={22,12,13,8,9,20,33,42,44,38,24,48,60,58,74,49,86,53};
index*list;
pleaseinputkey:
key）;
list=CreateList（record,N）;
datapostionid%d\n"
BlockSearch（list,record,N,BlockNum,key））;
通过本章的学习，对排序有较高层次的理解与认识，从平时的练习中可以看出排序是数据处理中经常用到的重要运算。
有序的顺序表可以采用查找效率较高的折半查找法，而无序的顺序表只能用效率较低的顺序查找法。
升级会员 