实验12顺序表和链表基本操作参考答案Word格式文档下载.docx
《实验12顺序表和链表基本操作参考答案Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《实验12顺序表和链表基本操作参考答案Word格式文档下载.docx（25页珍藏版）》请在冰豆网上搜索。
DataTypedata[MAXSIZE];
intlength;
}SeqList;
voidInit_SeqList（SeqList&
L）;
//创建空顺序表算法
voidShow_SeqList（SeqListL）;
//顺序表输出算法
voidCreate_SeqList（SeqList&
//顺序表创建算法
intInsert_SeqList（SeqList&
L,DataTypex,inti）;
//顺序表的插入算法
intDelete_SeqList（SeqList&
L,inti）;
//顺序表的删除算法
intLocate_SeqList（SeqListL,DataTypex）;
//顺序表的按值查找算法
voidSort_SeqList（SeqList&
//顺序表的排序算法
intInsert_SeqList_sort（SeqList&
L,DataTypex）;
//有序表的插入算法
voidMerge（SeqListLA,SeqListLB,SeqList&
LC）;
//两个有序顺序表的合并算法
voidmenu（）;
//菜单算法
voidmain（）
{menu（）;
}
voidmenu（）//菜单算法
SeqListL;
Init_SeqList（L）;
intm;
while
（1）
{
cout<
<
"
\n根据所做操作选择以下数字序号：
endl;
cout<
1:
创建顺序表2:
执行插入操作3:
执行删除操作"
4:
执行输出操作5:
执行查找操作6:
执行排序操作"
7:
执行有序表的插入操作8:
执行有序表的合并操作0:
退出"
intn,i,x;
cin>
>
n;
switch（n）
case1:
{
Create_SeqList（L）;
break;
}
case2:
cout<
请输入插入位置：
;
cin>
i;
cout<
endl<
请输入插入元素值：
x;
m=Insert_SeqList（L,x,i）;
if（m==1）
cout<
插入操作成功！
else
if（m==0）
cout<
插入位置不合法！
else
发生溢出！
case3:
请输入删除位置：
m=Delete_SeqList（L,i）;
删除操作成功！
删除位置不合法！
空表！
case4:
Show_SeqList（L）;
case5:
请输入所要查找的元素值：
m=Locate_SeqList（L,x）;
if（m==0）
所查找元素不在顺序表中！
所查找元素是顺序表的第"
m<
个元素！
case6:
Sort_SeqList（L）;
排序操作完成！
case7:
m=Insert_SeqList_sort（L,x）;
cout<
case8:
SeqListL1,L2,L3;
Init_SeqList（L1）;
Init_SeqList（L2）;
Init_SeqList（L3）;
创建有序表1：
Create_SeqList（L1）;
Sort_SeqList（L1）;
创建有序表2：
Create_SeqList（L2）;
Sort_SeqList（L2）;
有序表1：
Show_SeqList（L1）;
有序表2：
Show_SeqList（L2）;
Merge（L1,L2,L3）;
合并后：
Show_SeqList（L3）;
case0:
return;
}
}
L）//创建空顺序表算法
L.length=0;
voidShow_SeqList（SeqListL）//顺序表输出算法
if（L.length==0）
else
for（inti=0;
i<
L.length;
i++）
L.data[i]<
"
L）//顺序表创建算法
请输入元素个数:
依次输入各个元素的值:
for（inti=0;
cin>
L.data[i];
L,DataTypex,inti）//顺序表的插入算法
if（MAXSIZE<
=L.length）
return-1;
if（i<
1||i>
L.length+1）
return0;
for（intj=L.length-1;
j>
=i-1;
j--）
L.data[j+1]=L.data[j];
L.data[i-1]=x;
L.length++;
return1;
L,inti）//顺序表的删除算法
if（L.length==0）
L.length）
for（intj=i;
j<
j++）
L.data[j-1]=L.data[j];
L.length--;
intLocate_SeqList（SeqListL,DataTypex）//顺序表的按值查找算法
inti=0;
while（i<
L.length&
&
L.data[i]!
=x）
i++;
L.length）
returni+1;
L）//排序算法
inti,k,j;
DataTypetemp;
for（i=0;
L.length-1;
{
k=i;
for（j=i+1;
=L.length-1;
if（L.data[j]<
L.data[k]）
k=j;
if（i!
=k）
temp=L.data[i];
L.data[i]=L.data[k];
L.data[k]=temp;
L,DataTypex）//有序表的插入算法
x）
=i;
L.data[i]=x;
LC）//两个有序顺序表的合并算法
inti,j,k;
i=j=k=0;
LA.length&
LB.length）
if（LA.data[i]<
LB.data[j]）
LC.data[k]=LA.data[i];
i++;
k++;
else
LC.data[k]=LB.data[j];
j++;
LA.length）
LC.data[k]=LA.data[i];
k++;
while（j<
LC.data[k]=LB.data[j];
j++;
LC.length=k;
}输入输出结果：
图1-1主菜单
图1-2顺序表的创建和输出操作
图1-3顺序表的插入操作
图1-4顺序表的删除操作
图1-5顺序表的排序操作
图1-6有序表的插入操作
图1-7两个有序表的合并操作
单链表的源程序：
#include"
iostream"
typedefstructnode
DataTypedata;
structnode*next;
}LNode,*LinkList;
voidInit_LinkList（LinkList&
//创建空单链表
voidCreate1LinkList（LinkList&
L,intn）;
//前插入法创建单链表的算法
voidCreate2LinkList（LinkList&
//后插入法创建单链表的算法
voidPrintLinkList（LinkListL）;
//单链表的输出算法
intInsertLinkList（LinkList&
L,inti,DataTypex）;
//单链表的插入算法
intDeleteLinkList（LinkList&
//单链表的删除算法
voidSelect_Sort_LinkList（LinkList&
//链表的排序算法（选择排序）
voidInsert2（LinkListL,DataTypex）;
//有序表的插入
voidMerge（LinkListL1,LinkListL2,LinkList&
L3）;
//两个有序表的合并算法
//菜单函数
intmain（）
menu（）;
return0;
L）//创建空单链表
L=newLNode;
L->
next=NULL;
L,intn）//前插入法创建单链表的算法
LNode*s;
for（inti=1;
=n;
s=newLNode;
请输入第"
个元素的值：
s->
data;
s->
next=L->
next;
L->
next=s;
L,intn）//后插入法创建单链表的算法
LNode*s,*r=L;
r->
r=s;
r->
voidPrintLinkList（LinkListL）//单链表的输出算法
if（L->
next==NULL）
return;
当前单链表为：
LNode*p=L->
while（p）
p->
data<
p=p->
L,inti,DataTypex）//单链表的插入算法
intj=0;
LNode*p=L,*s;
while（p&
i-1）
if（!
p||j>
s=newLNode;
s->
data=x;
next=p->
next;
p->
next=s;
L,inti）//单链表的删除算法
next==NULL）
LNode*p=L,*q;
while（（p->
next!
=NULL）&
（j<
i-1））
if（（p->
next==NULL）||（j>
q=p->
next=q->
deleteq;
L）//链表的排序算法（选择排序）
空表，不需要排序！
LNode*p,*q,*s;
next==NULL）return;
for（p=L->
next!
=NULL;
p=p->
next）
s=p;
for（q=p->
q!
q=q->
if（q->
data）
s=q;
if（s!
=p）
temp=s->
data=p->
data=temp;
排序成功！
voidInsert2（LinkListL,DataTypex）//有序表的插入
while（p->
=NULL&
next->
next=p->
L3）//两个有序表的合并算法
LNode*p1,*p2,*p3,*s;
p1=L1->
p2=L2->
L3=p3=newLNode;
L3->
next=NULL;
while（p1&
p2）
if（p1->
data<
p2->
data）
s->
data=p1->
data;
p1=p1->
data=p2->
p2=p2->
p3->
p3=s;
if（p1）
next=p1;
if（p2）
next=p2;
voidmenu（）//菜单函数
LinkListL;
Init_LinkList（L）;
前插入创建单链表2:
尾插入创建单链表3:
执行插入操作"
执行删除操作5:
执行输出操作6:
执行有序表的合并操作0:
intn,i,x;
switch（n）
case1:
请输入结点个数：
Create1LinkList（L,i）;
PrintLinkList（L）;
case2:
Create2LinkList（L,i）;
case3:
if（InsertLinkList（L,i,x）==1）
case4:
m=DeleteLinkList（L,i）;
if（m==-1）
else
case5:
case6:
Select_Sort_LinkList（L）;
case7:
Insert2（L,x）;
case8:
LinkListL1,L2,L3;
Init_LinkList（L1）;
Init_LinkList（L2）;
Init_LinkList（L3）;
Create2LinkList（L1,i）;
Select_Sort_LinkList（L1）;
Create2L
升级会员 