数据结构试验报告.docx
《数据结构试验报告.docx》由会员分享，可在线阅读，更多相关《数据结构试验报告.docx（32页珍藏版）》请在冰豆网上搜索。
数据结构试验报告
顺序表
一、实验目的：
掌握顺序表的定位、插入、删除等操作。
二、实验内容：
（1）设线性表存放在向量A[arrsize]的前elenum个分量中，且递增有序。
试写一算法，将x插入到线性表的适当位置上，以保持线性表的有序性。
并且分析算法的时间复杂度。
（2）删除顺序表中所有等于X的数据元素。
三、实验结果与分析
实验内容
（1）源程序：
#include"stdio.h"
#include"stdlib.h"
#definearrsize1024
typedefstruct
{intdata[arrsize];
intlast;
}sequenlist;
sequenlist*A;
intInsert（intx,intelenum）
{inti,j;
if（elenum>=arrsize-1）
{printf（"overflow!
"）;return0;}
i=0;
while（（（*A）.data[i]<=x）&&（ii++;
for（j=elenum-1;j>=i;j--）
（*A）.data[j+1]=（*A）.data[j];
（*A）.data[i]=x;
elenum++;
return1;
}
intmain（）
{inta,i;intM;
printf（"PleaseinputM:
\n"）;
scanf（"%d",&M）;
for（i=0;i（*A）.data[i]=i*2+1;
printf（"Pleaseinputthenumberyouwanttoinsert:
\n"）;
scanf（"%d",&a）;
Insert（a,M）;
for（i=0;iprintf（"%d",（*A）.data[i]）;
system（"pause"）;
}
程序运行结果为：
四、实验心得与体会
通过本次实验让我进一步了解了顺序表的定位、插入、删除等操作。
实验过程中一定要仔细，不能让顺序表溢出，顺序表的空间要设置得恰当，太大会造成空间的浪费，太小会很容易造成顺序表的溢出。
单链表
一、实验目的：
掌握单链表的定位、插入、删除等操作。
二、实验内容：
（1）已知带头结点的动态单链表L中的结点是按整数值递增排列的，试写一算法将值为x的结点插入表L中，使L仍然有序。
（2）试编写在带头结点的动态单链表上实现线性表操作LENGTH（L）的算法，并将长度写入头结点的数据域中。
三、实验结果与分析
实验内容
（1）源程序：
#include
#include
#include
typedefstructnode
{
intdata;
structnode*next;
}linklist;
linklist*L;
linklist*INSERT（intx）
{
linklist*head,*s,*p,*q;
inti,j;
head=L;
p=head;q=head;
while（（p!
=NULL）&&（p->datap=p->next;
if（p->data>=x）
while（q->next!
=p）q=q->next;
{
s=malloc（sizeof（linklist））;
s->data=x;
q->next=p;
s->next=p;
q->next=s;
}
returnhead;
}
linklist*CREATLIST（）
{
intt;
linklist*head,*s,*r;
head=NULL;
r=NULL;
scanf（"%d",&t）;
while（t!
=0）
{
s=malloc（sizeof（linklist））;
s->data=t;
if（head==NULL）
head=s;
else
r->next=s;
r=s;
scanf（"%d",&t）;
}
if（r!
=NULL）
r->next=NULL;
returnhead;
}
intmain（）
{
intm;
linklist*h;
printf（"Pleaseinputthelistyouwanttomake:
\n"）;
L=CREATLIST（）;
printf（"Pleaseinputthenumberyouwanttoinsert:
\n"）;
scanf（"%d",&m）;
h=INSERT（m）;
printf（"\n"）;
while（h!
=NULL）
{printf（"%d",h->data）;h=h->next;}
system（"pause"）;
}
程序运行结果为：
实验内容
（2）源程序：
#include
#include
#include
typedefstructnode
{
intdata;
structnode*next;
}linklist;
linklist*L;
linklist*creatlist（）
{
intt;
linklist*head,*s,*r;
head=NULL;
r=NULL;
scanf（"%d",&t）;
while（t!
=0）
{
s=malloc（sizeof（linklist））;
s->data=t;
if（head==NULL）
head=s;
else
r->next=s;
r=s;
scanf（"%d",&t）;
}
if（r!
=NULL）
r->next=NULL;
returnhead;
}
intmain（）
{
linklist*p,*head1,*head2;
intn=0;
printf（"Pleaseintputthedataofthelinklist:
\n"）;
L=creatlist（）;
head1=L;
p=head1;
head2=p;
while（p!
=NULL）
{
printf（"%d",p->data）;
p=p->next;
}
p=head2;
head1=malloc（sizeof（linklist））;
head1->data=0;
head1->next=p;
while（p!
=NULL）
{n++;p=p->next;}
head1->data=n;
printf（"\nThelengthis:
%d\n",head1->data）;
p=head1;
while（p!
=NULL）
{
printf（"%d",p->data）;
p=p->next;
}
system（"pause"）;
}
程序运行结果为：
四、实验心得与体会
通过本次实验让我更加了解了单链表的插入删除定位等操作，进一步了解了单链表的定义和使用方法，同时也让我更加深入地认识到单链表中带头结点和不带头结点的区别，单链表适用于顺序存储，而顺序表适用于随机存储。
在实验时一定要仔细，任何一个错误哪怕是拼写错误都会导致程序的失败，而程序本身的错误在编译是不会报错，只会导致程序运行结果错误。
此时则需不断调试程序找出错误最终达到预期的结果。
堆栈和队列
一、实验目的：
a）掌握应用栈解决问题的方法。
b）掌握利用栈进行表达式求和的算法。
二、实验内容：
（1）设单链表中存放着n个字符，试编写算法，判断该字符串是否有中心对称关系，例如xyzzyx、xyzyx都算是中心对称的字符串。
要求用尽可能少的时间完成判断。
（提示：
将一半字符先依次进栈。
）
（2）设计算法判断一个算术表达式的圆括号是否正确配对。
（提示：
对表达式进行扫描，凡遇‘（’就进栈，遇‘）’就退掉栈顶的‘）’，表达式被扫描完毕，栈应为空。
）
三、实验结果与分析
实验内容
（1）源程序：
#include
#include
#include
#definemaxsize64
typedefstructnode
{
chardata;
structnode*next;
}linklist;
linklist*L;
typedefstruct
{
chardata[maxsize];
inttop;
}seqstack;
seqstack*s;
intMATCH（linklist*p,intn）
{
inti=0;
s->top=-1;
while（i{
if（s->top==maxsize-1）
{printf（"overflow!
"）;return0;}
else
{s->top++;s->data[s->top]=p->data;
p=p->next;i++;}
}
if（n%2!
=0）
p=p->next;
while（p）
{
s->top--;
if（s->data[s->top+1]==p->data）
{p=p->next;}
else
break;
}
if（p==NULL）
printf（"yes\n"）;
else
printf（"no\n"）;
}
linklist*creatlist（）
{charch;
linklist*head,*s;
head=NULL;
scanf（"%c",&ch）;
while（ch!
='\n'）
{
s=malloc（sizeof（linklist））;
s->data=ch;
s->next=head;
head=s;
scanf（"%c",&ch）;
}
returnhead;
}
intmain（）
{
linklist*q;
intn=0;
printf（"Pleaseinputcharacters:
\n"）;
L=creatlist（）;
q=L;
while（q!
=NULL）
{n++;q=q->next;}
MATCH（L,n）;
}
实验运行结果：
实验内容
（2）源程序：
#include"stdio.h"
#definemaxsize1024
typedefstruct
{chardata[maxsize];
inttop;
}seqstack;
seqstack*st;
Match（charexp[],intn）
{charst[maxsize];
inttop=-1,i=0,tag=1;
while（i{if（exp[i]==（'（'）&&tag==1）
{top++;
st[top]=exp[i];
}
if（exp[i]=='）'）
if（st[top]=='（'）top--;
elsetag=0;
i++;
}
if（top>=0）tag=0;
return（tag）;
}
main（）
{charc[100];intn=0,tag;
printf（"pleaseenterthestring:
\n"）;
scanf（"%s",c）;n=strlen（c）;
tag=Match（c,n）;
if（tag!
=0）printf（"Thestringismatched!
"）;
elseprintf（"Thestringisnotmatched!
"）;
system（"pause"）;
}_
程序运行结果为：
四、实验心得与体会
通过本次实验让我进一步了解了应用栈解决问题的方法和利用栈进行表达式求和的算法。
实验中需要注意形参和实参的类型长度要一致，否则就会导致错误。
任何变量都要有初值，否则也会导致程序编译不能通过。
在编程时原来的变量n因为没有附初值而出现错误，附了初值0后编译就能通过了。
串、递归算法
一、实验目的：
a）掌握串的应用。
b）掌握递归算法的设计方法。
二、实验内容：
（1）若X和Y是用结点大小为1的单链表表示的串，试设计一个算法找出X中第一个不在Y中出现的字符。
（2）设字符串采用单字符的链式存储结构，编程删除串s从位置i开始长度为k的子串。
三、实验结果与分析
实验内容
（1）源程序：
#include
#include
#include
typedefstructnode
{
chardata;
structnode*next;
}linklist;
linklist*X,*Y;
linklist*CREATLIST（）
{
charch;
linklist*head,*s,*r;
head=NULL;
r=NULL;
scanf（"%c",&ch）;
while（ch!
='$'）
{
s=malloc（sizeof（linklist））;
s->data=ch;
if（head==NULL）
head=s;
else
r->next=s;
r=s;
scanf（"%c",&ch）;
}
if（r!
=NULL）
r->next=NULL;
returnhead;
}
main（）
{linklist*p,*q,*pre;charch;
printf（"pleaseinputthestringX:
\n"）;
X=CREATLIST（）;
printf（"pleaseinputthestringY:
\n"）;
Y=CREATLIST（）;
p=X;q=Y;
while（p!
=NULL&&q!
=NULL）
{
while（q!
=NULL&&q->data!
=p->data）q=q->next;
if（q==NULL）
{printf（"Thecharacteris:
%c",p->data）;break;}
else
p=p->next;
if（p==NULL）
printf（"Can'tfound!
"）;
}
}_
实验运行结果为：
实验内容
（2）源程序：
#include
#include
#include
typedefstructnode
{
chardata;
structnode*next;
}linklist;
linklist*s;
linklist*CREATLIST（）
{
charch;
linklist*head,*s,*r;
head=NULL;
r=NULL;
scanf（"%c",&ch）;
while（ch!
='$'）
{
s=malloc（sizeof（linklist））;
s->data=ch;
if（head==NULL）
head=s;
else
r->next=s;
r=s;
scanf（"%c",&ch）;
}
if（r!
=NULL）
r->next=NULL;
returnhead;
}
delete（inti,intj）
{linklist*p,*r;intn;
p=s;
for（n=1;np=p->next;
for（n=1;n<=j;n++）
{r=p->next;
p->next=r->next;
free（r）;
}
p=s;
while（p!
=NULL）
{printf（"%c",p->data）;p=p->next;}
}
main（）
{inti,j;
printf（"pleaseinputstring:
\n"）;
s=CREATLIST（）;
printf（"pleaseinputinwhichnumberyouwanttodelete:
"）;
scanf（"%d",&i）;
printf（"pleaseinputhowmanynumbersyouwanttodelete:
"）;
scanf（"%d",&j）;
delete（i,j）;
}_
实验运行结果为：
四、实验心得与体会
通过本次实验让我进一步掌握了串的应用和递归算法的设计方法。
编程时循环语句的层次结构一定要弄清，在编写实验
（1）时因为嵌套了多个for循环而导致程序运行结果的错误，后来进行运用了while循环简化了程序并且解决了这一问题，因此程序只有不断进行分析和调试解决问题才能达到实验预期的效果。
二叉树
一、实验目的：
a）掌握二叉树的生成，以及前、中、后序遍历算法。
b）掌握应用二叉树递归遍历思想解决问题的方法。
二、实验内容：
（1）建立一棵二叉树。
对此树进行前序遍历、中序遍历及后序遍历，输出遍历序列。
（2）求二叉树中叶结点的个数。
三、实验结果与分析
实验内容
（1）源程序：
#include
#include
#include
#definemaxsize64
typedefstructnode
{
chardata;
structnode*lchild,*rchild;
}bitree;
bitree*h;
PREORRDER（bitree*t）
{
if（t）
{
printf（"%c",t->data）;
PREORRDER（t->lchild）;
PREORRDER（t->rchild）;
}
}
INORDER（bitree*t）
{
if（t）
{INORDER（t->lchild）;
printf（"%c",t->data）;
INORDER（t->rchild）;
}
}
POSTORDER（bitree*t）
{
if（t）
{POSTORDER（t->lchild）;
POSTORDER（t->rchild）;
printf（"%c",t->data）;
}
}
bitree*Q[maxsize];
bitree*CREATREE（）
{
charch;
intfront,rear;
bitree*root,*s;
root=NULL;
front=1;rear=0;
printf（"pleaseinputthecharacters:
"）;
scanf（"%c",&ch）;
while（ch!
='\n'）
{
s=NULL;
if（ch!
='@'）
{
s=malloc（sizeof（bitree））;
s->data=ch;
s->lchild=NULL;
s->rchild=NULL;
}
rear++;
Q[rear]=s;
if（rear==1）root=s;
else
{if（s&&Q[front]）
if（rear%2==0）Q[front]->lchild=s;
elseQ[front]->rchild=s;
if（rear%2==1）front++;
}
scanf（"%c",&ch）;
}
returnroot;
}
main（）
{
h=CREATREE（）;
printf（"Thepreorderis:
"）;
PREORRDER（h）;printf（"\n"）;
printf（"Theinorderis:
"）;
INORDER（h）;printf（"\n"）;
printf（"Thepostorderis:
"）;
POSTORDER（h）;
}_
程序运行结果为：
实验内容
（2）源程序：
#include
#include
#definemaxsize64
typedefstructnode
{
intdata;
structnode*lchild,*rchild;
}bitree;
bitree*t;
bitree*Q[maxsize];
bitree*CREATREE（）
{
charch;
intfront,rear;
bitree*root,*s;
root=NULL;
front=1;rear=0;
printf（"pleaseinputthecharacters:
"）;
scanf（"%c",&ch）;
while（ch!
='\n'）
{
s=NULL;
if（ch!
='@'）
{
s=malloc（sizeof（bitree））;
s->data=ch;
s->lchild=NULL;
s->rchild=NULL;
}
rear++;
Q[rear]=s;
if（rear==1）root=s;
else
{if（s&&Q[front]）
if（rear%2==0）Q[front]->lchild=s;
elseQ[front]->rchild=s;
if（rear%2==1）front++;
}
scanf（"%c",&ch）;
}
returnroot;
}
inti=0;
voidfindleaf（bitree*b）
{if（b==NULL）
return;
if（b->lchild==NULL&&b->rchild==NULL）
{printf（"%c",b->data）;i++;}
else{
findleaf（b->lchild）;
findleaf（b->rchild）;
}
}
main（）
{t=CREATREE（）;
printf（"Theleafis:
"）;
findleaf（t）;
printf（"\nThenumberis:
%d",i）;
}
程序运行结果为：
四、实验心得与体会
通过本次实验让我进一步掌握了二叉树的生
升级会员 