数据结构实验教案信息1.docx
《数据结构实验教案信息1.docx》由会员分享，可在线阅读，更多相关《数据结构实验教案信息1.docx（30页珍藏版）》请在冰豆网上搜索。
数据结构实验教案信息1
数据结构实验教案
（使用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[j-1];
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;
}0
}
五、实验结果：
64,6,7,89,12,24
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（seqcqueue
升级会员 