数据结构实验教案信息.docx
《数据结构实验教案信息.docx》由会员分享,可在线阅读,更多相关《数据结构实验教案信息.docx(35页珍藏版)》请在冰豆网上搜索。
数据结构实验教案信息
数据结构实验教案
(使用C语言)
数学与计算机科学学院
张青
实验1:
顺序表的基本操作
一、实验目的:
1.会定义线性表的顺序存储类型;
2.熟悉C程序的基本结构,掌握程序中的用户头文件、实现文件和主文件之间的相互关系及各自的作用;
3.熟悉对线性表的一些基本操作和具体的函数定义;
4.熟悉C操作环境的使用以及多文件程序的输入、编辑、调试和运行的全过程。
二、实验要求:
1.理解实验内容中所给出程序的含义;
2.用此程序上机运行、调试;
3.屏幕显示结果,能结合程序进行分析;
4.能按照你对顺序表操作的需要,重新改写主函数并运行。
实验内容:
训练对顺序表的插入和取数据元素操作,顺序插入、取打印1-10这几个数字。
三、实验程序:
#include
#definemaxsize100
typedefintdatatype;
typedefstruct
{
datatypelist[maxsize];
intsize;
}seqlist;
slinitiate(seqlist*L1);
slinsert(seqlist*L2,inti,datatypex);
slget(seqlistL3,inti,datatype*x);
main(void)
{
seqlistmylist;
inti,x;
slinitiate(&mylist);
for(i=0;i<10;i++)
{
if(slinsert(&mylist,i,i+1)==0)
{
printf("wrong!
\n");
return;
}
}
for(i=0;i<10;i++)
{
if(slget(mylist,i,&x)==0)
{
printf("wrong!
\n");
return;
}
elseprintf("%d",x);
}
}
slinitiate(seqlist*L1)
{
L1->size=0;
}
intslinsert(seqlist*L2,inti,datatypex)
{
intj;
if(L2->size>=maxsize)
{
printf("thelistisfull,can'tbeinserted!
\n");
return0;
}
elseif(i<0||i>L2->size)
{
printf("theparameterisillegal!
\n");
return0;
}
else
{
for(j=L2->size;j>i;j--)L2->list[j]=L2->list[i];
L2->list[i]=x;
L2->size++;
return1;
}
}
intslget(seqlistL3,inti,datatype*x)
{
if(i<0||i>L3.size-1)
{
printf("theparameteriisillegal!
\n");
return0;
}
else
{
*x=L3.list[i];
return1;
}
}
_
四、实验结果:
12345678910
五、程序各部分功能及实验结果分析:
实验2:
不带头结点单链表的基本操作
一、实验目的:
1.会定义单链表的结点类型;
2.熟悉对单链表的一些基本操作和具体的函数定义;
3.了解和掌握单链表的调用格式。
二、实验要求:
1.认真阅读和掌握实验内容所给的程序,并上机运行;
2.保存程序运行结果,并结合程序进行分析;
3.尝试自己调试修改程序并试运行。
三、实验内容:
编写算法实现不带头结点单链表的初始化操作、插入操作和删除操作。
四、实验程序:
#include
#include
#include
typedefintdatatype;
typedefstructnode
{
datatypedata;
structnode*next;
}nslnode;
voidnsllinitiate(nslnode**head);
intnsllinsert(nslnode**head,inti,datatypex);
intnslldelete(nslnode**head,inti,datatype*x);
voidmain(void)
{
datatypetest[6]={64,6,7,89,12,24};
nslnode*head,*p;
intn=6,i,*x;
nsllinitiate(&head);
for(i=1;i<=n;i++)
nsllinsert(&head,i,test[i-1]);
for(i=n;i>=1;i--)
{
nslldelete(&head,i,x);
printf(“%d”,*x);
}
}
voidnsllinitiate(nslnode**head)
{
*head=NULL;
}
intnsllinsert(nslnode**head,inti,datatypex)
{
nslnode*p,*q;
intj;
p=*head;j=1;
while(p!
=NULL&&j{
p=p->next;j++;
}
if(j!
=i-1&&i!
=1)
{
printf(“插入位置参数错!
”);
return0;
}
if((q=(nslnode*)malloc(sizeof(nslnode)))==NULL)exit
(1);
q->data=x;
if(I==1)
{
q->next=*head;
*head=q;
}
else
{
q->next=p->next;
p->next=q;
}
return1;
}
intnslldelete(nslnode**head,inti,datatype*x)
{
nslnode*p,*q;
intj;
p=*head;j=1;
while(p!
=NULL&&p->next!
=NULL&&j{
p=p->next;j++
}
if(j!
=i-1&&i!
=1)
{
printf(“删除位置参数错!
”);
return0;
}
if(i==1)
{
q=p;
head=(*head)->next;
}
else
{
q=p->next;
p->next=p->next->next;
}
*x=q->data;free(q);
return1;
}
五、运行结果:
2412897664
六、程序各部分功能及实验结果分析:
实验3:
带头结点单链表中数据就地逆置
一、实验目的:
1.会定义单链表的结点类型;
2.熟悉对单链表的一些基本操作和具体的函数定义;
3.了解和掌握单链表的调用格式。
二、实验要求:
1.认真阅读和掌握实验内容所给的程序,并上机运行;
2.保存程序运行结果,并结合程序进行分析;
3.尝试自己调试修改程序并试运行。
三、实验内容:
编写算法实现带头结点单链表的就地逆置,即利用原带头结点单链表的结点空间把数据元素序列逆置。
四、实验程序:
#include
#include
#include
typedefintdatatype;
typedefstructsnode
{
datatypedata;
structsnode*next;
}slnode;
sllinitiate(slnode**head);
intsllinsert(slnode*head,inti,datatypex);
intslldelete(slnode*head,inti,datatypex);
intsllget(slnode*head,inti,datatype*x);
intsllnotempty(slnode*head);
linlistsurt(slnode*head);
linlistinsert(slnode*head,datatypex);
converse(slnode*head);
main(void)
{
datatypetest[6]={64,6,7,89,12,24};
slnode*head,*p;
intn=6,i;
sllinitiate(&head);
for(i=1;i<=n;i++)
sllinsert(head,i,test[i-1]);
linlistsort(head);
linlistinsert(head,25);
converse(head);
p=head->next;
while(p!
=NULL)
{
printf("%d",p->data);
p=p->next;
}
}
sllinitiate(slnode**head)
{
if((*head=(slnode*)malloc(sizeof(slnode)))==NULL)exit
(1);
(*head)->next=NULL;
}
intsllinsert(slnode*head,inti,datatypex)
{
slnode*p,*q;
intj;
p=head;j=0;
while(p!
=NULL&&j{
p=p->next;j++;
}
if(j!
=i-1)
{
printf("theinsert-positionparameteriswrong!
\n");
return0;
}
if((q=(slnode*)malloc(sizeof(slnode)))==NULL)exit
(1);
q->data=x;
q->next=p->next;p->next=q;
return1;
}
intslldelete(slnode*head,inti,datatypex)
{
slnode*p,*q;
intj;
p=head;j=0;
while(p->next!
=NULL&&j{
p=p->next;j++;
}
if(j!
=i-1)
{
printf("thedelete-positionparameteriswrong!
\n");
return0;
}
q=p->next;p->next=p->next->next;
x=q->data;
free(q);
return1;
}
intsllget(slnode*head,inti,datatype*x)
{
slnode*p;
intj;
p=head;j=0;
while(p->next!
=NULL&&j
{
p=p->next;j++;
}
if(j!
=i)
{
printf("theget-positionparameteriswrong!
\n");
return0;
}
*x=p->data;
return1;
}
intsllnotempty(slnode*head)
{
if(head->next==NULL)return0;
elsereturn1;
}
linlistsort(slnode*head)
{
slnode*curr,*pre,*p,*q;
p=head->next;
head->next=NULL;
while(p!
=NULL)
{
curr=head->next;
pre=head;
while(curr!
=NULL&&curr->data<=p->data)
{
pre=curr;
curr=curr->next;
}
q=p;
p=p->next;
q->next=pre->next;
pre->next=q;
}
}
linlistinsert(slnode*head,datatypex)
{
slnode*curr,*pre,*q;
curr=head->next;
pre=head;
while(curr!
=NULL&&curr->data<=x)
{
pre=curr;
curr=curr->next;
}
if((q=(slnode*)malloc(sizeof(slnode)))==NULL)exit
(1);
q->data=x;
q->next=pre->next;
pre->next=q;
}
converse(slnode*head)
{
slnode*p,*q;
p=head->next;
head->next=NULL;
while(p!
=NULL)
{
q=p;
p=p->next;
q->next=head->next;
head->next=q;
}
}
五、实验结果:
896425241276
六、程序各部分功能及实验结果分析:
实验4:
顺序堆栈的基本操作
一、实验目的:
1.会定义顺序堆栈抽象数据类型;
2.熟悉顺序堆栈的基本结构;
3.熟悉对顺序堆栈的一些基本操作和具体的函数定义;
二、实验要求:
1.理解实验内容中所给出程序的含义;
2.用此程序上机运行、调试;
3.屏幕显示结果,能结合程序进行分析;
4.能按照你对顺序堆栈操作的需要,重新改写主函数并运行。
三、实验内容:
打印依次出栈的数据元素序列
四、实验程序:
#include
#include
#definemaxstacksize100
typedefintdatatype;
typedefstruct
{
datatypestack[maxstacksize];
inttop;
}seqstack;
voidstackinitiate(seqstack*s);
intstacknotempty(seqstacks);
intstackpush(seqstack*s,datatypex);
intstackpop(seqstack*s,datatype*d);
intstacktop(seqstacks,datatype*d);
voidmain(void)
{
seqstackmystack;
inti,x;
stackinitiate(&mystack);
for(i=0;i<10;i++)
{
if(stackpush(&mystack,i+1)==0)
{
printf("wrong!
\n");
return;
}
}
if(stacktop(mystack,&x)==0)
{
printf("wrong!
\n");
return;
}
else
printf("todaythedataofthestacktopis:
%d\n",x);
printf("thepopdataonebyoneis:
\n");
while(stacknotempty(mystack))
{
stackpop(&mystack,&x);
printf("%d",x);
}
}
voidstackinitiate(seqstack*s)
{
s->top=0;
}
intstacknotempty(seqstacks)
{
if(s.top<=0)return0;
elsereturn1;
}
intstackpush(seqstack*s,datatypex)
{
if(s->top>=maxstacksize)
{
printf("stackisfull,can'tinsert!
\n");
return0;
}
else
{
s->stack[s->top]=x;
s->top++;
return1;
}
}
intstackpop(seqstack*s,datatype*d)
{
if(s->top<=0)
{
printf("stackisempty!
\n");
return0;
}
else
{
s->top--;
*d=s->stack[s->top];
return1;
}
}
intstacktop(seqstacks,datatype*d)
{
if(s.top<=0)
{
printf("stackisempty!
\n");
return0;
}
else
{
*d=s.stack[s.top-1];
return1;
}
}
五、程序运行结果:
10987654321
六、程序各部分功能及实验结果分析:
实验5:
判断一个字符序列是否是回文
一、实验目的:
1.会定义顺序堆栈和顺序循环队列的抽象数据类型;
2.熟悉顺序堆栈和顺序循环队列的基本结构,掌握程序中的用户头文件、实现文件和主文件之间的相互关系及各自的作用;
3.熟悉对顺序堆栈和顺序循环队列的一些基本操作和具体的函数定义;
二、实验要求:
1.理解实验内容中所给出程序的含义;
2.用此程序上机运行、调试;
3.屏幕显示结果,能结合程序进行分析;
4.能按照你对顺序堆栈和顺序循环队列操作的需要,重新改写主函数并运行。
实验内容:
编程序判断一个字符序列是否是回文。
要求程序从键盘输入一个字符串,字符串长度小于等于80,用于判断回文的字符串中不包括字符串的结束标记符。
三、实验内容:
利用顺序堆栈和顺序循环队列,判断一个输入的字符序列是否是回文
四、实验程序:
#include
#include
#definemaxsize80
typedefchardatatype;
typedefstruct
{
datatypelist[maxsize];
inttop;
}seqstack;
typedefstruct
{
datatypelist[maxsize];
intfront;
intcount;
}seqcqueue;
voidscqinitiate(seqcqueue*q);
intscqappend(seqcqueue*q,datatypex);
intscqdelete(seqcqueue*q,datatype*d);
intscqgettop(seqcqueueq,datatype*d);
intscqnotempty(seqcqueueq);
voidssinitiate(seqstack*s);
intsspush(seqstack*s,datatypex);
intsspop(seqstack*s,datatype*d);
intssgettop(seqstacks,datatype*d);
intssnotempty(seqstacks);
voidpalindrome(charstr[],intn)
{
seqstackmystack;
seqcqueuemyqueue;
charx,y;
inti;
ssinitiate(&mystack);
scqinitiate(&myqueue);
for(i=0;i{
scqappend(&myqueue,str[i]);
sspush(&mystack,str[i]);
}
while(scqnotempty(myqueue)==1&&ssnotempty(mystack)==1)
{
scqdelete(&myqueue,&x);
sspop(&mystack,&y);
if(x!
=y)
{
printf("bushihuiwen!
");
return;
}
}
printf("shihuiwen!
");
}
voidenterstr(charstr[],int*n)
{
printf("qingcharuzifuchuan(buchaoguo80zifu):
");
scanf("%s",str);
*n=strlen(str);
}
voidmain(void)
{
charch,str[80];
intn;
while
(1)
{
enterstr(str,&n);
palindrome(str,n);
printf("\ngoon?
(y/n):
");
scanf("%s",&ch);
if(ch=='Y'||ch=='y')continue;
elsereturn;
}
}
voidscqinitiate(seqcqueue*q)
{
q->front=0;
q->count=0;
}
intscqappend(seqcqueue*q,datatypex)
{
intrear;
if(q->count==maxsize)
{
printf("队列已满无?
!
\n");
return0;
}
else
{
rear=q->front+q->count;
q->list[rear]=x;
q->count++;
return1;
}
}
intscqdelete(seqcqueue*q,datatype*d)
{
if(q->count==0)
{
printf("循环队列已空!
\n");
return0;
}
else
{
*d=q->list[q->front];
q->front=(q->front+1)%maxsize;
q->count--;
return1;
}
}
intscqgettop(seqcqueueq,datatype*d)
{
if(q.count==0)
{
printf("循环队列已空!
\n");
return0;
}
else
{
*d=q.list[q.front];
return1;
}
}
intscqnotempty(seqcqueueq)
{
if(q.count==0)