C语言数据结构线性表的基本操作实验报告Word文档下载推荐.docx
《C语言数据结构线性表的基本操作实验报告Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《C语言数据结构线性表的基本操作实验报告Word文档下载推荐.docx（38页珍藏版）》请在冰豆网上搜索。
//创建线性表
voidShowList（Sqlist*p）;
//输出顺序线性表
voidListDelete（Sqlist*p,inti,int&
e）;
//在顺序线性表中删除第i个元素，并用e返回其值
voidListInsert（Sqlist*p）;
//在顺序线性表中第i个元素前插入新元素e
voidListEmpty（Sqlist*p）;
//判断L是否为空表
voidGetList（Sqlist*p,inti,int&
//用e返回L中第i个数据元素的值
voidListInsert（Sqlist*p,inti,inte）;
boolcompare（inta,intb）;
voidLocateElem（Sqlist*L,inte）;
//在顺序线性表L中查找第1个值与e满足compare（）d元素的位序
voidMergeList_L（Sqlist*La,Sqlist*Lb）;
//归并
voidmain（）
SqlistLa;
SqlistLb;
intn,m,x;
menu（）;
scanf（"
%d"
&
n）;
while（n）
{
switch（n）
{
case0:
;
break;
case1:
InitList（&
La）;
break;
case2:
ListEmpty（&
case3:
printf（"
请输入插入的位序:
\n"
）;
scanf（"
m）;
请出入要插入的数:
x）;
ListInsert（&
La,m,x）;
case4:
请输入删除元素的位序:
ListDelete（&
删除的元素为:
%d\n"
x）;
case5:
请输入要找的与线性表中相等的数:
LocateElem（&
La,m）;
case6:
请输入查找的位序:
GetList（&
La中第%d个元素的值为%d\n"
m,x）;
case7:
ShowList（&
case8:
Lb）;
case9:
MergeList_L（&
La,&
归并成功!
"
}
menu（）;
scanf（"
}
}
/*菜单*/
voidmenu（）
printf（"
********************\n\n"
0.退出\n\n"
1.创建线性表La\n\n"
2.判断La是否为空表\n\n"
3.插入元素（La）\n\n"
4.删除元素（La）\n\n"
5.定位元素（La）\n\n"
6.取元素（La）\n\n"
7.输出线性表\n\n"
8.创建线性表Lb\n\n"
9.归并为一个线性表La\n\n"
/*创建顺序线性表L*/
voidInitList（Sqlist*L）
intn;
inti=0;
L->
elem=（int*）malloc（LIST_INIT_SIZE*sizeof（int））;
if（NULL==L->
elem）
printf（"
储存分配失败!
else
L->
length=0;
listsize=LIST_INIT_SIZE;
输入顺序表a:
while（n）
L->
elem[i]=n;
i++;
length++;
listsize=L->
listsize-4;
/*输出顺序线性表*/
voidShowList（Sqlist*p）
inti;
if（0==p->
length）
数组为空!
for（i=0;
i<
p->
length;
i++）
%d"
p->
elem[i]）;
/*判断L是否为空表*/
voidListEmpty（Sqlist*p）
L是空表!
L不是空表!
/*在顺序线性表中第i个元素前插入新元素e*/
voidListInsert（Sqlist*p,inti,inte）
int*newbase;
int*q1;
int*q2;
while（i<
1||i>
length+1）
您输入的i超出围!
\n请重新输入要插入的位置\n:
i）;
if（p->
length>
=p->
listsize）
newbase=（int*）realloc（p->
elem,（p->
listsize+LISTINCREMENT）*sizeof（int））;
if（!
newbase）
exit（0）;
else
p->
elem=newbase;
listsize+=LISTINCREMENT;
q1=&
（p->
elem[i-1]）;
for（q2=&
elem[p->
length-1]）;
q2>
=q1;
--q2）
*（q2+1）=*q2;
*q1=e;
++p->
/*/在顺序线性表中删除第i个元素，并用e返回其值*/
e）
int*q1,*q2;
请重新输入:
e=*q1;
q2=p->
elem+p->
length-1;
for（++q1;
q1<
=q2;
++q1）
*（q1-1）=*q1;
--p->
/*对比a与b相等*/
boolcompare（inta,intb）
{
if（a==b）
return1;
return0;
/*在顺序线性表L中查找第1个值与e满足compare（）d元素的位序*/
voidLocateElem（Sqlist*L,inte）
inti=1;
int*p;
p=L->
elem;
=L->
length&
&
!
compare（*p++,e））
++i;
if（i<
第1个与e相等的元素的位序为%d\n"
i）;
没有该元素!
/*用e返回L中第i个数据元素的值*/
Sqlist*p1;
p1=p;
e=p1->
elem[i-1];
}
/*已知顺序线性表La和Lb是元素按值非递减排列*/
/*把La和Lb归并到La上,La的元素也是按值非递减*/
voidMergeList_L（Sqlist*La,Sqlist*Lb）
inti=0,j=0,k,t;
Sqlist*pa,*pb;
pa=La;
pb=Lb;
pa->
j<
pb->
if（pa->
elem[i]>
=pb->
elem[j]）
if（pa->
listsize==0）
{
newbase=（int*）realloc（pa->
elem,（pa->
if（!
exit（0）;
}
for（k=pa->
k>
=i;
k--）
pa->
elem[k+1]=pa->
elem[k];
pa->
elem[i]=pb->
elem[j];
j++;
while（j<
if（pa->
listsize<
pb->
length-j）
for（j;
j<
j++,i++）
for（i=0;
length/2;
t=pa->
elem[i];
pa->
elem[i]=pa->
elem[pa->
length-i-1];
length-i-1]=t;
（2）源程序（实验要求2和4）
typedefstructLNode
intdata;
structLNode*next;
}LNode,*LinkList;
LinkListInitList（）;
voidShowList（LinkListL）;
voidListDelete（LinkListL,inti,int&
voidListEmpty（LinkListL）;
voidGetList（LinkListL,inti,int&
voidListInsert（LinkListL,inti,inte）;
voidLocateElem（LinkListL,inte）;
LinkListMergeList_L（LinkListLa,LinkListLb）;
inttotal=0;
LinkListLa;
LinkListLb;
La=（LinkList）malloc（sizeof（structLNode））;
La->
next=NULL;
Lb=（LinkList）malloc（sizeof（structLNode））;
Lb->
intm;
intx;
La->
next=InitList（）;
ListEmpty（La）;
请输入要插入到第几个节点前:
请输入插入的数据:
ListInsert（La,m,x）;
ListDelete（La,m,x）;
LocateElem（La,m）;
GetList（La,m,x）;
ShowList（La）;
Lb->
La=MergeList_L（La,Lb）;
归并成功\n"
2.判断是否为空表\n\n"
3.插入元素\n\n"
4.删除元素\n\n"
5.定位元素\n\n"
6.取元素\n\n"
9.归并两线性表\n\n"
//创建链式线性表L
LinkListInitList（）
intcount=0;
LinkListpHead=NULL;
LinkListpEnd,pNew;
pEnd=pNew=（LinkList）malloc（sizeof（structLNode））;
请输入数据:
pNew->
data）;
while（pNew->
data）
count++;
if（count==1）
pNew->
next=pHead;
pEnd=pNew;
pHead=pNew;
pEnd->
next=pNew;
pNew=（LinkList）malloc（sizeof（structLNode））;
free（pNew）;
total=total+count;
returnpHead;
//判断L是否为空表
voidListEmpty（LinkListL）
next）
此表为空表!
此表不为空表!
//在链式线性表中第i个元素前插入新元素e
voidListInsert（LinkListL,inti,inte）
LinkListp;
LinkLists;
p=L;
intj=0;
while（p&
i-1）
p=p->
next;
++j;
if（!
p||j>
不存在您要找的节点!
s=（LinkList）malloc（sizeof（int））;
s->
data=e;
next=p->
p->
next=s;
插入节点成功!
//输出链式线性表
voidShowList（LinkListL）
if（p==NULL）
while（p）
p=p->
//在链式线性表中删除第i个元素，并用e返回其值
LinkListq;
while（p->
next&
next）||j>
没有找到要删除的位置!
q=p->
next=q->
e=q->
data;
free（q）;
//用e返回L中第i个数据元素的值
++j;
（p）||j>
没有找到要查找的位置!
e=p->
//对比a与b相等
//在链式线性表L中查找第1个值与e满足compare（）d元素的位序
voidLocateElem（LinkListL,inte）
compare（p->
data,e））
i++;
if（NULL==p->
if（0==compare（p->
if（compare（p->
LinkListMergeList_L（LinkListLa,LinkListLb）
inti,j,k;
LinkListpa_1,pb_1,pa_2,pb_2,pc,pd;
pa_1=La->
pc=pa_2=La;
pb_1=pb_2=Lb->
if（pa_1->
data>
pb_1->
pc=pa_2=Lb;
pa_1=Lb->
pb_1=pb_2=La->
while（pa_1&
pb_1）
if（pa_1->
=pb_1->
pa_2->
next=pb_1;
pb_2=pb_1->
pb_1->
next=pa_1;
pb_1=pb_2;
pa_2
升级会员 