数据结构实验指导手册Word文档格式.docx
《数据结构实验指导手册Word文档格式.docx》由会员分享，可在线阅读，更多相关《数据结构实验指导手册Word文档格式.docx（47页珍藏版）》请在冰豆网上搜索。
\n删除位置错误!
）;
return0;
for（j=i+1;
j<
=（*L）.length;
j++）
（*L）.data[j-1]=（*L）.data[j];
（*L）.length--;
/*生成顺序表*/
voidcreatlist（SeqList*L）
{intn,i,j;
printf（"
请输入顺序表L的数据个数：
\n"
scanf（"
%d"
&
n）;
for（i=0;
i<
n;
i++）
data[%d]="
i）;
scanf（"
&
（（*L）.data[i]））;
（*L）.length=n-1;
}/*creatlist*/
/*输出顺序表L*/
printout（SeqList*L）
{inti;
for（i=0;
=（*L）.length;
data[%d]="
i）;
printf（"
（*L）.data[i]）;
}/*printout*/
main（）
{SeqList*L;
charcmd;
inti,t,x;
clrscr（）;
creatlist（L）;
do
{
\ni,I-----插入\n"
d,D-----删除\n"
q,Q-----退出\n"
{cmd=getchar（）;
}while（（cmd!
='
i'
）&
&
（cmd!
I'
d'
D'
q'
Q'
））;
switch（cmd）
{case'
:
case'
printf（"
\nPleaseinputtheDATA:
scanf（"
x）;
\nWhere?
i）;
insert（L,i,x）;
printout（L）;
break;
case'
:
\nWheretoDelete?
i）;
delete（L,i）;
printout（L）;
break;
2、有序顺序表的合并
[问题描述]已知顺序表la和lb中的数据元素按非递减有序排列，将la和lb表中的数据元素，合并成为一个新的顺序表lc
[基本要求]lc中的数据元素仍按非递减有序排列，并且不破坏la和lb表
#include<
{DataTypedata[maxnum];
intlength;
}SeqList;
intMergeQL（SeqListla,SeqListlb,SeqList*lc）
{inti,j,k;
if（la.length+1+lb.length+1>
maxnum）
\narrayoverflow!
i=j=k=0;
while（i<
=la.length&
j<
=lb.length）
{if（la.data[i]<
=lb.data[j]）
lc->
data[k++]=la.data[i++];
else
data[k++]=lb.data[j++];
/*处理剩余部分*/
while（i<
=la.length）lc->
data[k++]=la.data[i++];
while（j<
=lb.length）lc->
length=k-1;
{SeqListla={{3,4,7,12,15},4};
SeqListlb={{2,5,7,15,18,19},5};
SeqListlc;
inti;
if（MergeQL（la,lb,&
lc））
for（i=0;
i<
=lc.length;
%4d"
lc.data[i]）;
}
实验二单链表实验
1、掌握用VisualC++6.0上机调试单链表的基本方法
2、掌握单链表的插入、删除、查找、求表长以及有序单链表的合并算法的实现
二、实现内容
1、单链表基本操作的实现
[问题描述]要在带头结点的单链表h中第i个数据元素之前插入一个数据元素x，首先需要在单链表中寻找到第i-1个结点并用指针p指示，然后申请一个由指针s指示的结点空间，并置x为其数据域值，最后修改第i-1个结点，并使x结点的指针指向第i个结点，要在带头结点的单链表h中删除第i个结点，首先要计数寻找到第i个结点并使指针p指向其前驱第i-1个结点，然后删除第i个结点并释放被删除结点空间。
[基本要求]用链式存储结构实现存储
[实现提示]链式存储结构不是随机存储结构，即不能直接取到单链表中某个结点，而要从单链表的头结点开始一个一个地计数寻找。
stdio.h>
malloc.h>
typedefcharDataType;
typedefstructnode{
DataTypedata;
/*结点的数据域*/
structnode*next;
/*结点的指针域*/
}ListNode;
voidInit_List（ListNode**L）
（*L）=（ListNode*）malloc（sizeof（ListNode））;
/*产生头结点*/
（*L）->
next=NULL;
intList_Length（ListNode*L）
intn=0;
ListNode*p=L->
next;
while（p!
=NULL）
n++;
p=p->
returnn;
ListNode*GetNode（ListNode*L,inti）
intj;
ListNode*p;
p=L;
j=0;
/*从头结点开始扫描*/
while（p->
next&
j!
=i）/*顺指针向后扫描,直到p->
next为NULL或i=j为止*/
{
j++;
if（i==j）
returnp;
/*找到了第i个结点*/
else
returnNULL;
/*当i<
0或i>
0时,找不到第i个结点*/
}
voidInsertList（ListNode*L,DataTypex,inti）
{
ListNode*p,*s;
p=GetNode（L,i-1）;
/*寻找第i-1个结点*/
if（p==NULL）/*i<
1或i>
n+1时插入位置i有错*/
{printf（"
positionerror"
return;
s=（ListNode*）malloc（sizeof（ListNode））;
s->
data=x;
s->
next=p->
p->
next=s;
voidDeleteList（ListNode*L,inti）
ListNode*p,*r;
p=GetNode（L,i-1）;
/*找到第i-1个结点*/
if（p==NULL||p->
next==NULL）/*i<
n时,删除位置错*/
return;
r=p->
/*使r指向被删除的结点a*/
next=r->
/*将ai从链上删除*/
free（r）;
}
/*使用头插法建立带头结点链表算法*/
ListNode*CreatListF（void）
charch;
ListNode*head=（ListNode*）malloc（sizeof（ListNode））;
/*生成头结点*/
ListNode*s;
/*工作指针*/
head->
ch=getchar（）;
/*读入第1个字符*/
while（ch!
\n'
）
/*生成新结点*/
data=ch;
/*将读入的数据放入新结点的数据域中*/
next=head->
head->
ch=getchar（）;
/*读入下一字符*/
returnhead;
/*使用尾插法建立带头结点链表算法*/
ListNode*CreatListR1（void）
charch;
ListNode*head=（ListNode*）malloc（sizeof（ListNode））;
ListNode*s,*r;
r=head;
/*尾指针初值也指向头结点*/
while（（ch=getchar（））!
r->
r=s;
/*终端结点的指针域置空,或空表的头结点指针域置空*/
returnhead;
/*复制链表A中的内容到表B中*/
voidcopy（ListNode*a,ListNode*b）
ListNode*pa=a->
ListNode*u;
ListNode*rb=b;
while（pa!
u=（ListNode*）malloc（sizeof（ListNode））;
u->
data=pa->
data;
rb->
next=u;
rb=u;
pa=pa->
rb->
/*输出带头结点的单链表*/
voidDisplaySL（ListNode*la,char*comment）
{ListNode*p;
p=la->
next;
if（p）printf（"
\n%s\n"
comment）;
while（p）
%4c"
p->
data）;
p=p->
/*主函数*/
main（）
{ListNode*la,*lb,*lc,*p;
intn,x,i;
\n用头插法建立链表la，请输入节点内容:
la=CreatListF（）;
DisplaySL（la,"
新生成链la节点内容:
\n链表la的长度:
%2d"
List_Length（la））;
\n请输入要插入的元素:
%c"
\n请输入要插入的位置：
InsertList（la,x,i）;
插入后链la节点内容"
\n请输入要删除元素的位置：
DeleteList（la,i）;
DisplaySL（la,"
删除后链la节点内容"
\n用尾插法建立链表lb，请输入节点内容:
fflush（stdin）;
lb=CreatListR1（）;
DisplaySL（lb,"
新生成链lb节点内容:
Init_List（&
lc）;
copy（la,lc）;
DisplaySL（lc,"
复制生成的链lc节点内容:
2、有序单链表的合并
[问题描述]已知单链表la和lb中的数据元素按非递减有序排列，将la和lb中的数据元素,合并为一个新的单链表lc,lc中的数据元素仍按非递减有序排列。
[基本要求]不破坏la表和lb表的结构。
#include<
alloc.h>
#defineNULL0
typedefintDataType;
typedefstructSLNode
{DataTypedata;
structSLNode*next;
}slnodetype;
intMergeSL（slnodetype*la,slnodetype*lb,slnodetype**lc）;
intCreateSL（slnodetype*la,intn）;
voidDisplaySL（slnodetype*la,char*comment）;
{slnodetype*la,*lb,*lc,*p;
intn,m;
la=（slnodetype*）malloc（sizeof（slnodetype））;
la->
lb=（slnodetype*）malloc（sizeof（slnodetype））;
lb->
lc=（slnodetype*）malloc（sizeof（slnodetype））;
\n输入链la节点数:
n）;
\n输入链la节点内容:
CreateSL（la,n）;
链la节点内容:
\n输入链lb节点数:
m）;
\n输入链lb节点内容:
CreateSL（lb,m）;
链lb节点内容:
if（MergeSL（la,lb,&
lc））DisplaySL（lc,"
合成后的链lc:
getchar（）;
intMergeSL（slnodetype*la,slnodetype*lb,slnodetype**lc）
{slnodetype*pa,*pb,*pc;
lc=（slnodetype*）malloc（sizeof（slnodetype））;
pa=la->
pb=lb->
pc=*lc;
while（pa&
pb）
pc->
next=（slnodetype*）malloc（sizeof（slnodetype））;
pc=pc->
if（pa->
data<
=pb->
data）
{pc->
else{pc->
data=pb->
pb=pb->
while（pa）/*插入la链的剩余段*/
pc->
pc=pc->
pc->
}
/*插入lb链的剩余段*/
while（pb）
/*生成单链表*/
intCreateSL（slnodetype*la,intn）
slnodetype*p,*q;
q=la;
for（i=1;
=n;
{p=（slnodetype*）malloc（sizeof（slnodetype））;
data）;
q->
next=p;
q=p;
next=NULL;
return1;
/*输出单链表*/
voidDisplaySL（slnodetype*la,char*comment）
{slnodetype*p;
p=la->
if（p）printf（"
while（p）
\n%3d"
p->
实验三循环链表实验
1、掌握用VisualC++6.0上机调试循环链表的基本方法
2、进一步掌握循环单链表的插入、删除、查找算法的实现
1.约瑟夫环问题
[问题描述]设有N个人围坐一圈，现从某个人开始报数，数到M的人出列，接着从出列的下一个人开始重新报数，数到M的人以出列，如此下去，直到所有人都出列为此。
试设计确定他们的出列次序序列的程序。
[基本要求]选择单向循环链表作为存储结构模拟整个过程，并依次输出列的各人的编号。
[实现提示]程序运行之后，首先要求用户指定初始报数的下限值，可以n<
=30,此题循环链表可不设头节点，而且必须注意空表和非空表的界限。
如n=8,m=4时，若从第一个人，设每个人的编号依次为1，2，3，…开始报数，则得到的出列次序为4，8，5，2，1，3，7，6，
如下图所示，内层数字表示人的编号，每个编号外层的数字代表人出列的序号。
malloc.h>
typedefstructnode
{intnum;
}linklist;
linklist*creat（head,n）/*使n个人围成一圈，并给每个人标识号数*/
linklist*head;
intn;
{linklist*s,*p;
inti;
s=（linklist*）malloc（sizeof（linklist））;
head=s;
num=1;
p=s;
for（i=2;
=n;
{s=（linklist*）malloc（sizeof（linklist））;
num=i;
p->
next=head;
return（head）;
}/*creat*/
linklist*select（linklist*head,intm）
{linklist*p,*q;
inti,t;
p=head;
t=1;
q=p;
/*q为p的前趋指针*/
p=p->
do
t=t+1;
/*报一次数*/
if（t%m==0）
p->
num）;
q->
free（p）;
p=q->
else{q=p;
}while（q!
=p）;
head=p;
return（head）;
}/*select*/
{intn,m;
\ninputthetotalnumber:
n="
&
\ninputthenumbertocall:
m="
head=creat（head,n）;
head=select（head,m）;
\nthelastoneis:
head->
}/*main*/
思考题：
编程实现两个循环单链表的合并。
实验四栈、队列的实现及应用
1、掌握栈和队列的顺序存储结构和链式存储
升级会员 