单链表各种操作的C语言实现Word下载.docx
《单链表各种操作的C语言实现Word下载.docx》由会员分享，可在线阅读，更多相关《单链表各种操作的C语言实现Word下载.docx（16页珍藏版）》请在冰豆网上搜索。
L=q;
/*将L重置为空表*/
StatusClearList（structLNode*L）
LinkList*p,*q;
p=L->
while（p）
q=p->
free（p）;
p=q;
L->
/*判断链表是否为空表*/
StatusListEmpty（LinkList*L）
if（L->
next）
returnFALSE;
else
returnTRUE;
/*返回单链表中元素的个数*/
intListLength（structLNode*L）
inti=0;
LinkList*p=L->
i++;
p=p->
returni;
/*L为带头节点的单链表的头指针，当第i个元素存在时，其值赋给e,并返回OK*/
StatusGetElem（structLNode*L,inti,ElemType*e）
intj=1;
while（p&
&
j<
i）
j++;
p||j>
returnERROR;
*e=p->
data;
/*返回L中第一个与e满足关系compare（）的数据元素的位序，
若给存在返回值为0，compare（）是数据元素的判定函数*/
intLocateElem（structLNode*L,ElemTypee,Status（*compare）（ElemType,ElemType））
if（compare（p->
data,e））
p=p->
return0;
/*所cur_e是L中的数据元素，且给就第一个，则用pre_e返回它的前驱*/
StatusPriorElem（structLNode*L,ElemTypecur_e,ElemType*pre_e）
LinkList*q,*p=L->
while（p->
//q指向p的后继
if（q->
data==cur_e）
*pre_e=p->
returnINFEASIBLE;
/*若cur_e是L中的数据元素，且不是最后一个，则用next_e返回它的后继*/
StatusNextElem（structLNode*L,ElemTypecur_e,ElemType*next_e）
LinkList*p;
if（p->
*next_e=p->
next->
/*在带头节点的单链表L中的第i个位置之前插入元素e*/
StatusListInsert（structLNode*L,inti,ElemTypee）
intj=0;
structLNode*p=L,*s=NULL;
i-1）
s=（structLNode*）malloc（sizeof（structLNode））;
s）
printf（"
mallocerror~\n"
）;
//p->
next=s;
s->
data=e;
next=p->
p->
//s->
next=NULL;
//p=s;
/*在带头节点的单链表中删除第i个元素，并有e返回其值*/
StatusListDelete（LinkList*L,inti,ElemType*e）
LinkList*p=L,*q;
intj=0;
next&
i-1）
next||j>
next=q->
*e=q->
free（q）;
/*依次对L的每个元素调用vi（）,打印输出语句*/
StatusListTraverse（structLNode*L,void（*vi）（ElemType））
vi（p->
data）;
\n"
/*对单链表进行排序处理*/
structLNode*sort（structLNode*head）
LinkList*p;
intn,i,j;
inttemp;
n=ListLength（head）;
if（head==NULL||head->
next==NULL）
returnhead;
p=head->
for（j=1;
j<
n;
++j）
for（i=0;
i<
n-j;
++i）
data>
p->
data）
temp=p->
data=p->
data=temp;
/*对单链表进行逆置*/
LinkList*reverse（LinkList*head）
LinkList*p1,*p2=NULL,*p3=NULL;
p1=head->
while（p1!
=NULL）
p3=p1->
p1->
next=p2;
p2=p1;
p1=p3;
head->
//head=p2;
Statusequal（ElemTypec1,ElemTypec2）
if（c1==c2）
returnTRUE;
returnFALSE;
/*将所有在线性表Lb中但不在La中的数据元素插入到La中*/
voidUnion（LinkList*La,LinkList*Lb）
ElemType*e;
intLa_len,Lb_len;
inti;
La_len=ListLength（La）;
Lb_len=ListLength（Lb）;
for（i=1;
=Lb_len;
i++）
GetElem（Lb,i,e）;
//取Lb中第i个元素赋给e
LocateElem（La,*e,equal））//La中不存在和e相同的元素，则插入
ListInsert（La,++La_len,*e）;
voidprint（ElemTypec）
%4d"
c）;
/*合并两个单链表，La和Lb中的数据是按非递减排列，归并后的Lc还是安非递减排列*/
voidMergeList（LinkList*La,LinkList*Lb,LinkList**Lc）
inti=1,j=1,k=0;
ElemType*ai,*bj;
ai=（ElemType*）malloc（sizeof（ElemType））;
bj=（ElemType*）malloc（sizeof（ElemType））;
InitList（Lc）;
while（i<
=La_len&
=Lb_len）
GetElem（La,i,ai）;
GetElem（Lb,j,bj）;
if（*ai<
*bj）
ListInsert（*Lc,++k,*ai）;
++i;
ListInsert（*Lc,++k,*bj）;
++j;
=La_len）
GetElem（La,i++,ai）;
while（j<
GetElem（Lb,j++,bj）;
/*只遍历一次，找到单链表中的中间节点
1定义两个指针，一个指针每次移动两个步长（快指针），另一个指针每次移动一个数据（慢指针）
2.当快指针到达链表尾部的时候，慢指针就到了链表的中间节点
在程序中也可以判断一个单链表是否有环，如果快指针一定能够追赶上慢指针，否则就会以NULL结束*/
LinkList*Searchmid（LinkList*head）
if（NULL==head）
returnNULL;
if（head->
LinkList*mid=head;
LinkList*p=mid->
while（（p!
=NULL）&
（NULL!
=p->
next））
mid=mid->
returnmid;
下面主要是单链表的一个测试的程序。
Statuscomp（ElemTypec1,ElemTypec2）
if（c1==c2）
voidvisit（ElemTypec）
voidmain（）
LinkList*L;
LinkList*mid;
mid=（structLNode*）malloc（sizeof（structLNode））;
ElemType*e,e0,*e1;
Statusi;
intj,k;
e=（ElemType*）malloc（sizeof（ElemType））;
e1=（ElemType*）malloc（sizeof（ElemType））;
i=InitList（&
L）;
for（j=1;
=6;
j++）
i=ListInsert（L,1,j）;
在L的表头依次插入1～6后：
L="
ListTraverse（L,visit）;
L中间节点的值为mid=：
"
mid=Searchmid（L）;
%d\n"
mid->
L逆置后的输出：
ListTraverse（reverse（L）,visit）;
L排序后依次为：
ListTraverse（sort（L）,visit）;
i=ListEmpty（L）;
L是否为空：
i=%d（1:
是，0:
否）\n"
i）;
i=ClearList（L）;
清空L后：
L是否为空：
i=%d\n"
=10;
ListInsert（L,j,j）;
在L的表尾依次插入1~10后：
GetElem（L,5,e）;
第5个元素的值为：
*e）;
for（j=0;
=1;
k=LocateElem（L,j,comp）;
if（k）
第%d个元素的值为%d\n"
k,j）;
没有值为%d的元素\n"
j）;
=2;
GetElem（L,j,e1）;
i=PriorElem（L,*e1,e）;
if（i==INFEASIBLE）
元素%d无前驱\n"
*e1）;
元素%d的前驱为：
*e1,*e）;
for（j=ListLength（L）-1;
=ListLength（L）;
i=NextElem（L,*e1,e）;
if（i==INFEASIBLE）
元素%d无后继\n"
元素%d的后继为：
k=ListLength（L）;
for（j=k+1;
j>
=k;
j--）
i=ListDelete（L,j,e）;
if（i==ERROR）
删除第%d个数据失败\n"
删除的元素为：
依次输出L的元素：
DestroyList（L）;
销毁L后：
L=%u\n"
L）;
*************************************************\n"
LinkList*La,*Lb;
La）;
if（i==1）
=5;
i=ListInsert（La,j,j）;
La="
ListTraverse（La,print）;
InitList（&
Lb）;
i=ListInsert（Lb,j,2*j）;
Lb="
ListTraverse（Lb,print）;
Union（La,Lb）;
newLa="
LinkList*La_1,*Lb_1,*Lc_1;
inta[4]={3,5,8,11},b[7]={2,6,8,9,11,15,20};
La_1）;
=4;
ListInsert（La_1,j,a[j-1]）;
La_1="
ListTraverse（La_1,print）;
Lb_1）;
=7;
ListInsert（Lb_1,j,b[j-1]）;
Lb_1="
ListTraverse（Lb_1,print）;
MergeList（La_1,Lb_1,&
Lc_1）;
Lc_1="
ListTraverse（Lc_1,print）;
下面是在Linux下的部分运行结果：
L=654321
4
L=123456
i=0（1:
否）
L=
i=1
L=12345678910
5
没有值为0的元素
第1个元素的值为1
元素1无前驱
元素2的前驱为：
1
元素9的后继为：
10
元素10无后继
删除第11个数据失败
123456789
L=7954544
*************************************************
La=12345
Lb=246810
newLa=123456810
La_1=35811
Lb_1=2689111520
Lc_1=235688911111520
StatusInitList_CL（structLNode**L）
next=*L;
StatusDestroyList_CL（structLNode*L）
structLNode*q=L->
next,*p=（L）->
while（q!
=（L））
L=NULL;
StatusClearList_CL（structLNode*L）
L=L->
while（p!
=L）
next=L;
StatusListEmpty_CL（LinkList*L）
next==L）
re
升级会员 