级数据结构验证性实验指导书Word格式文档下载.docx
《级数据结构验证性实验指导书Word格式文档下载.docx》由会员分享,可在线阅读,更多相关《级数据结构验证性实验指导书Word格式文档下载.docx(48页珍藏版)》请在冰豆网上搜索。
\n删除位置错误!
for(j=i+1;
j<
=(*L).length;
j++)
(*L).data[j-1]=(*L).data[j];
(*L).length--;
voidcreatlist(Seqlist*L)
{intn,i;
printf("
请输入顺序表L的数据个数:
\n"
scanf("
%d"
&
n);
for(i=0;
i<
n;
i++)
data[%d]="
i);
((*L).data[i]));
(*L).length=n-1;
voidprintout(Seqlist*L)
{inti;
data[%d]="
(*L).data[i]);
voidmain()
{
Seqlist*L;
charcmd;
inti,x;
L=(Seqlist*)malloc(sizeof(Seqlist));
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;
\nWheretoDelete?
deleteList(L,i);
}
}while((cmd!
2、有序顺序表的合并
[问题描述]已知顺序表la和lb中的数据元素按非递减有序排列,将la和lb表中的数据元素,合并成为一个新的顺序表lc
[基本要求]lc中的数据元素仍按非递减有序排列,并且不破坏la和lb表
{DataTypedata[maxnum];
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&
=lb.length)
{if(la.data[i]<
=lb.data[j])
lc->
data[k++]=la.data[i++];
else
data[k++]=lb.data[j++];
=la.length)lc->
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))
=lc.length;
%4d"
lc.data[i]);
实验二单链表实验
1、掌握用VisualC++6.0上机调试单链表的基本方法
2、掌握单链表的插入、删除、查找、求表长以及有序单链表的合并算法的实现
3、进一步掌握循环单链表的插入、删除、查找算法的实现
二、实现内容
1、单链表基本操作的实现
[问题描述]要在带头结点的单链表h中第i个数据元素之前插入一个数据元素x,首先需要在单链表中寻找到第i-1个结点并用指针p指示,然后申请一个由指针s指示的结点空间,并置x为其数据域值,最后修改第i-1个结点,并使x结点的指针指向第i个结点,要在带头结点的单链表h中删除第i个结点,首先要计数寻找到第i个结点并使指针p指向其前驱第i-1个结点,然后删除第i个结点并释放被删除结点空间。
[基本要求]用链式存储结构实现存储
[实现提示]链式存储结构不是随机存储结构,即不能直接取到单链表中某个结点,而要从单链表的头结点开始一个一个地计数寻找。
#include<
stdio.h>
malloc.h>
typedefint
DataType;
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时,删除位置错*/
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->
);
/*主函数*/
voidmain()
{ListNode*la,*lb,*lc;
intx,i;
\n用头插法建立链表la,请输入节点内容:
la=CreatListF();
DisplaySL(la,"
新生成链表la节点内容:
\nthelengthofla:
%2d"
List_Length(la));
\n请输入要插入的元素:
%c"
x);
\n请输入要插入的位置:
i);
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表的结构。
typedefstructSLNode
{DataTypedata;
structSLNode*next;
}slnodetype;
voidMergeSL(slnodetype*la,slnodetype*lb,slnodetype**lc);
intCreateSL(slnodetype*la,intn);
voidDisplaySL(slnodetype*la,char*comment);
{slnodetype*la,*lb,*lc;
intn,m;
la=(slnodetype*)malloc(sizeof(slnodetype));
la->
lb=(slnodetype*)malloc(sizeof(slnodetype));
lb->
lc=(slnodetype*)malloc(sizeof(slnodetype));
\n输入链表la节点数:
\n输入链表la节点内容:
CreateSL(la,n);
链表la节点内容:
\n输入链表lb节点数:
m);
\n输入链表lb节点内容:
CreateSL(lb,m);
thecontentoflb:
MergeSL(la,lb,&
DisplaySL(lc,"
合成后的链表lc:
voidMergeSL(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)
pc=pc->
pc->
/*插入lb链的剩余段*/
while(pb)
/*生成单链表*/
intCreateSL(slnodetype*la,intn)
{inti;
slnodetype*p,*q;
q=la;
for(i=1;
i<
=n;
i++)
{p=(slnodetype*)malloc(sizeof(slnodetype));
&
q->
next=p;
q=p;
return1;
/*输出单链表*/
voidDisplaySL(slnodetype*la,char*comment)
{slnodetype*p;
p=la->
if(p)printf("
while(p)
{printf("
\n%3d"
p->
3.约瑟夫环问题
[问题描述]设有N个人围坐一圈,现从某个人开始报数,数到M的人出列,接着从出列的下一个人开始重新报数,数到M的人以出列,如此下去,直到所有人都出列为此。
试设计确定他们的出列次序序列的程序。
[基本要求]选择单向循环链表作为存储结构模拟整个过程,并依次输出列的各人的编号。
[实现提示]程序运行之后,首先要求用户指定初始报数的下限值,可以n<
=30,此题循环链表可不设头节点,而且必须注意空表和非空表的界限。
如n=8,m=4时,若从第一个人,设每个人的编号依次为1,2,3,…开始报数,则得到的出列次序为4,8,5,2,1,3,7,6,
如下图所示,内层数字表示人的编号,每个编号外层的数字代表人出列的序号。
typedefstructnode
{intnum;
}linklist;
linklist*creat(linklist*head,intn)/*使n个人围成一圈,并给每个人标识号数*/
{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;
intt;
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;
linklist*head=(linklist*)malloc(sizeof(linklist));
\ninputthetotalnumber:
n="
&
\ninputthenumbertocall:
m="
head=creat(head,n);
head=select(head,m);
\nthelastoneis:
head->
}/*main*/
思考题:
编程实现两个循环单链表的合并。
实验三栈、队列的实现及应用
1、掌握栈和队列的顺序存储结构和链式存储结构,以便在实际背景下灵活运用。
2、掌握栈和队列的特点,即先进后出与先进先出的原则。
3、掌握栈和队列的基本操作实现方法。
1、实现栈的顺序存储
#defineMAXSIZE100
typedefintElemType;
{ElemTypedata[MAXSIZE];
inttop;
}SeqStack;
voidIn