数据结构报告.docx
《数据结构报告.docx》由会员分享，可在线阅读，更多相关《数据结构报告.docx（25页珍藏版）》请在冰豆网上搜索。
数据结构报告
实验
（一）线性表的顺序存储的基本操作
一、实验问题描述：
基于线性表存储结构特征，对一些常见数据存储存储问题给出用顺序存储方式得以实现基本功能。
如创建线性表InitList（&L），销毁线性表DestroyList（&L），求表长LisrLength（L），获取元素GetElem（L,I,&e），查找元素LocatElem（L,e,compare（）），插入元素ListInsert（&L,i,e），删除元素ListDelect（&L,I,&e），遍历线性表ListTraverse（L,visit（））。
二、算法和数据结构设计：
#definemaxlen100
typedefstruct{
intdata[maxlen];
intlistlen;
}seqlist;
定义maxlen为100，定义seqlist为具有100的整形数组以及用listlen表示其表长.
voidinitial_list（seqlist*L）//创建线性表
intlength（seqlistL）//获得表长
voidget_element（seqlistL,inti,int*x）//获取现行表中的元素
intlist_locate（seqlistL,intx）//查找线性表中的元素
voidadd_list（seqlist*L,intn,intx）//增加线性表中的元素
voidlist_delete（seqlist*L,intx）//删除线性表中的元素
display（seqlistL）//遍历线性表并将其输出
三、C语言源程序：
#definemaxlen100
typedefstruct{
intdata[maxlen];
intlistlen;
}seqlist;
voidinitial_list（seqlist*L）{
L->listlen=0;
}
intlength（seqlistL）{
returnL.listlen;
}
voidget_element（seqlistL,inti,int*x）{
if（i<1||i>L.listlen）
{
printf（"outofrange"）;
}
else
{*x=L.data[i-1];
}
}
intlist_locate（seqlistL,intx）{
inti;
for（i=0;iif（L.data[i]==x）return（i+1）;
return（-999）;
}
voidadd_list（seqlist*L,intn,intx）
{
inti;
if（L->listlen>maxlen）
{
printf（"overflow"）;
return;
}
elseif（n<1||n>L->listlen）{
printf（"positionerror"）;
return;
}
L->listlen++;
for（i=L->listlen-1;i>=n;i--）
{
L->data[i]=L->data[i-1];
}
L->data[n-1]=x;
}
voidlist_delete（seqlist*L,intx）
{
inti;
if（L->listlen<=0）
{
printf（"error"）;
return;
}
elseif（x>L->listlen||x<=0）
{
printf（"positionerror"）;
return;
}
L->listlen--;
for（i=x;i<=L->listlen;i++）
{
L->data[i-1]=L->data[i];
}
}
display（seqlistDL）{
inti;
printf（"Theseqlistis:
\n"）;
for（i=0;iprintf（"%d",DL.data[i]）;
}
}
main（）{
inti,len,j,y,select,n,x;
seqlist*p;
seqlistl;
p=&l;
initial_list（&l）;
do{
printf（"****************************************"）;
printf（"****************************************"）;
printf（"0initial"）;
printf（"1length"）;
printf（"2get_element"）;
printf（"3locate"）;
printf（"4insert"）;
printf（"5delete"）;
printf（"6create"）;
printf（"7display"）;
printf（"8exit\n"）;
printf（"\nPleaseselect:
"）;
scanf（"%d",&select）;
switch（select）{
case0:
initial_list（&l）;
break;
case1:
printf（"lengthoftheseqlistis:
%d",length（l））;
break;
case2:
printf（"\nPleaseinputtheNumberofseqlist:
"）;
scanf（"%d",&i）;
get_element（l,i,&y）;
printf（"thedatais:
%d\n",y）;
break;
case3:
printf（"Pleaseinputthedatayouwanttolocate:
"）;
scanf（"%d",&y）;
printf（"thepositionis:
%d\n",list_locate（l,y））;
break;
case4:
printf（"PLeaseinputtheinsertposition:
"）;
scanf（"%d",&n）;
printf（"PLeaseinputtheinsertData:
"）;
scanf（"%d",&x）;
add_list（&l,n,x）;
break;
case6:
printf（"Pleaseinputlengthofseqlist:
"）;
scanf（"%d",&len）;
for（i=0;iprintf（"inputdata[%d]",i+1）;
scanf（"%d",&l.data[i]）;
p->listlen++;
}
break;
case7:
display（l）;
}
}while（select!
=8）;
}
四、程序测试：
五、复杂度分析：
initial_list（seqlist*L）复杂度为o
（1）;
length（seqlistL）复杂度为o
（1）
get_element（seqlistL,inti,int*x）复杂度为o
（1）
list_locate（seqlistL,intx）复杂度为o
（1）
add_list（seqlist*L,intn,intx）复杂度为o
（1）
list_delete（seqlist*L,intx）复杂度为o
（1）
display（seqlistL）复杂度为o（n）
实验
（二）线性表的链式存储的基本操作
一、实验问题描述：
基于线性表存储结构特征，对一些常见数据存储存储问题给出用链式存储方式得以实现基本功能。
如创建新链表creatlist（Lnode**L），销毁链表destorylist（Lnode**L），置空表clearlist（Lnode**L），求表长longlist（Lnode**L），插入元素insertlist（Lnode**L,inti,inte），删除元素deletelist（Lnode**L,inti），遍历链表输出链表元素outputlist（Lnode**L），求链表的平均值floataveragelist（Lnode**L）。
。
二、算法和数据结构设计：
#include
typedefstructLnode{
intdata;//链表中的数据
structLnode*next;//指针域
}Lnode;//链式线性表的结构体
intwelcome（）;//欢迎界面
intcreatlist（Lnode**L）;//创建新链表
intdestorylist（Lnode**L）;//销毁链表
intclearlist（Lnode**L）;//置空表
intlonglist（Lnode**L）;//求表长
intinsertlist（Lnode**L,inti,inte）;//插入元素
intdeletelist（Lnode**L,inti）;//删除元素
intoutputlist（Lnode**L）;//遍历链表输出链表元素
floataveragelist（Lnode**L）;//求链表的平均值
三、C语言源程序：
#include
typedefstructLnode{
intdata;
structLnode*next;
}Lnode;
intwelcome（）;
intcreatlist（Lnode**L）;
intdestorylist（Lnode**L）;
intinitlist（Lnode**L）;
intlonglist（Lnode**L）;
intinsertlist（Lnode**L,inti,inte）;
intdeletelist（Lnode**L,inti）;
intoutputlist（Lnode**L）;
floataveragelist（Lnode**L）;
intmain（）
{
inta,m,n;
floatb;
charch='y';
Lnode*L=NULL;
while（ch=='y'||ch=='Y'）{
switch（welcome（））{
case1:
{
printf（"Pleaseenterthelinkedlist:
\n"）;
a=creatlist（&L）;
if（a!
=0）
printf（"Createsuccess!
"）;
break;
}
case2:
{
if（destorylist（&L）!
=0）
printf（"Listdeletedsuccessfully!
"）;
break;
}
case3:
{
a=clearlist（&L）;
if（a!
=0）
printf（"Listhasblank!
"）;
break;
}
case4:
{
if（L!
=NULL）
printf（"Thelengthofalinkedlistis%d",longlist（&L））;
else
a=longlist（&L）;
break;
}
case5:
{
printf（"Pleaseenterthelocationtoinserttheelements:
"）;
scanf（"%d",&m）;
printf（"Pleaseenterinserttheelements:
"）;
scanf（"%d",&n）;
a=insertlist（&L,m,n）;
if（a!
=0）
printf（"Insertthesuccess!
"）;
else
printf（"Insertfailed!
"）;
break;
}
case6:
{
printf（"Pleaseenterthelocationyouwanttodeletetheelement:
"）;
scanf（"%d",&m）;
a=deletelist（&L,m）;
if（a!
=0）
printf（"Deletesuccess!
"）;
else
printf（"Removefailed!
"）;
break;
}
case7:
{
if（outputlist（&L）==0）
printf（"Pleasere-createthelist!
"）;
elseif（L->next==NULL）
printf（"Lineartableisempty!
"）;
break;
}
case8:
{
if（（L->next!
=NULL）&&（L!
=NULL））{
printf（"Theaveragelistis%.4f\n",averagelist（&L））;
}
else
printf（"Cannotbeobtained!
"）;
break;
}
default:
{
printf（"Pleaseenteragain!
"）;
break;
}
}
printf（"Whethertocontinueoperations?
YorN?
"）;
fflush（stdin）;
ch=getchar（）;
}
}
intcreatlist（Lnode**L）{
Lnode*p;
*L=（Lnode*）malloc（sizeof（Lnode））;
p=*L;
while
（1）{
scanf（"%d",&（p->data））;
if（p->data==0）break;
p->next=（Lnode*）malloc（sizeof（Lnode））;
p=p->next;
}
p->next=NULL;
return1;
}
intdestorylist（Lnode**L）{
Lnode*p;
p=*L;
while（p!
=NULL）{
p=p->next;
free（*L）;
*L=p;
}
*L=NULL;
return1;
}
intclearlist（Lnode**L）{
Lnode*p;
p=*L;
while（p->next!
=NULL）{
p=p->next;
free（*L）;
*L=p;
}
return1;
}
intlonglist（Lnode**L）{
inti=0;
Lnode*p;
p=*L;
if（*L==NULL）
printf（"Thelistdoesnotexist!
\n"）;
else{
while（p->next!
=NULL）{
i++;
p=p->next;
}
}
returni;
}
intinsertlist（Lnode**L,inti,inte）{
Lnode*p,*s;
intj;
j=1;
p=*L;
s=（Lnode*）malloc（sizeof（Lnode））;
if（i<1||i>longlist（L））
return0;
if（i==1）{
s->data=e;
s->next=p;
*L=s;
}
else{
while（jj++;
p=p->next;
}
s->data=e;
s->next=p->next;
p->next=s;
}
}
intdeletelist（Lnode**L,inti）{
Lnode*p,*q;
intj;
p=*L;
q=*L;
if（i<1||i>longlist（L））return0;
if（i==1）{
*L=p->next;
free（p）;
}
else{
for（j=1;jp=p->next;
for（j=1;jq=q->next;
q->next=p->next;
free（p）;
}
return1;
}
intoutputlist（Lnode**L）{
Lnode*p;
p=*L;
if（*L==NULL）{
printf（"Thelistdoesnotexist!
\n"）;
return0;
}
else{
while（p->next!
=NULL）{
printf（"%d",p->data）;
p=p->next;
}
}
return1;
}
floataveragelist（Lnode**L）{
inti=0,totle=0;
floatave;
Lnode*p;
p=*L;
if（（（*L）->next==NULL）||（（*L）==NULL））return0;
while（p->next!
=NULL）{
totle+=p->data;
p=p->next;
i++;
}
ave=1.0*totle/i;
returnave;
}
intwelcome（）{
inta;
printf（"***************************************************\n"）;
printf（"**1.Createalinkedlist**\n"）;
printf（"**2.Destoryalinkedlist**\n"）;
printf（"**3.clearalinkedlist**\n"）;
printf（"**4.thelengthofalist**\n"）;
printf（"**5.Insertelement**\n"）;
printf（"**6.deleteelement**\n"）;
printf（"**7.showtheelementofalinklist**\n"）;
printf（"**8.Seektheaverage**\n"）;
printf（"***************************************************\n"）;
printf（"Pleaseenterthenumbertobecarriedout:
"）;
scanf（"%d",&a）;
returna;
}
四、程序测试：
五、复杂度分析：
creatlist（Lnode**L）复杂度o
（1）;
destorylist（Lnode**L）复杂度o
（1）;
clearlist（Lnode**L）复杂度o
（1）;
longlist（Lnode**L）复杂度o（n）;
insertlist（Lnode**L,inti,inte）复杂度o（n）;
deletelist（Lnode**L,inti）复杂度o（n）;
outputlist（Lnode**L）复杂度o
（1）;
averagelist（Lnode**L）复杂度o（n）;
实验（三）二叉树的基本操作
一实验问题描述：
基于二叉链表，实现二叉树的基本功能。
如：
Creat_Bintree（Bintree*root）用递归建立二叉树，treavelpre1（Bintreet）按照前序递归遍历二叉树，treavelpre2（Bintreet）按照前序非递归遍历二叉树，treavelmid1（Bintreet）按照中序递归遍历二叉树，treavelmid2（Bintreet）按照中序非递归遍历二叉树，treavellate2（Bintreet）按照后序递归遍历二叉树，Leaves_Num1（Bintreet）递归法求叶子结点个数Leaves_Num2（Bintreet）非递归法求叶子结点个数treavellevell（Bintreet）按照层次遍历二叉树，Depth（Bintreet）递归法求树的高度
二、C源程序实现
#include"stdio.h"
#include"conio.h"
#defineM100
typedefstructBinnode{
chardata;
structBinnode*lchild;
structBinnode*rchild;
}Binnode,*Bintree;
typedefstructstack{
Bintreedata[M];
intflag[M];
inttop;
}stack;
typedefstructqueue{
Bintreedata[M];
intfront;
intrear;
}queue;
voidCreat_Bintree（Bintree*root）;按照前序遍历建立二叉树
voidtreavelpre1（Bintreet）;/*按照前序递归遍历二叉树
voidtreavelpre2（Bintreet）;/*按照前序非递归遍历二叉树voidtreavelmid1（Bintreet）;/*按照中序递归遍历二叉树
voidtreavelmid2（Bintreet）;/*按照中序非递归遍历二叉树
voidtreavellate1（Bintreet）;/*按照后序递归遍历二叉树
voidtreavellate2（Bintreet）;/*按照后序非递归遍历二叉树
intLeaves_Num1（
升级会员 