C语言静态链表.docx

C语言静态链表.docx

《C语言静态链表.docx》由会员分享，可在线阅读，更多相关《C语言静态链表.docx（18页珍藏版）》请在冰豆网上搜索。

C语言静态链表

#include"stdio.h"

#include"windows.h"

#defineMAXSIZE100//链表长度

typedefcharElemType;

typedefstruct

{

ElemTypedata;//存储数据

intcur;//存储游标值

}component,SLinkList[MAXSIZE];

voidInitSpace（SLinkListL）;/*1、函数功能：

建立备用链表*/

intInitList（SLinkListL）;/*2、函数功能：

构造空链表；返回值：

空表在数组中的位置*/

intMalloc（SLinkListspace）;/*3、函数功能：

链表非空就返回备用链表的第一个结点，否则返回0*/

voidScheFunc（）;/*4、函数功能：

打印进度条*/

boolListEmpty（SLinkListL,intn）;/*5、函数功能：

判断L中表头位序为n的链表是否空*/

intListLength（SLinkListL,intn）;/*6、函数功能：

计算表头为n的链表的长度*/

boolListInsert（SLinkListL,int*n,inti,ElemTypee）;/*7、函数功能：

数据插入*/

voidVisit（ElemTypee）;/*8、函数功能：

打印元素*/

voidListTraverse（SLinkListL,intn,void（*vi）（ElemTypee））;/*9、函数功能：

遍历结点并打印;n:

表示头结点下标*/

intClearList（SLinkListL,intn）;/*10、函数功能：

清空链表，转化到备用链表去*/

intGetElem（SLinkListL,intn,intpos,ElemType&e）;/*11、函数功能：

获取对应位置的元素；*/

intLocateElem（SLinkListL,intn,ElemTypee）;/*12、函数功能：

通过元素查询第一次位置*/

intPriorElem（SLinkListL,intn,intpos,ElemType&e0,ElemType&e）;/*13、函数功能：

查找e的前驱元素*/

intNextElem（SLinkListL,intn,intpos,ElemType&e0,ElemType&e）;/*14、函数功能：

查找e的后继元素*/

intListDelete（SLinkListL,int&n,inti,ElemType*e）;/*15、函数功能：

删除元素;n:

表头，i：

删除的位置*/

voidFree（SLinkListL,intk）;/*16、函数功能：

把不用的结点放到备用链表；k不用结点的下标*/

/*1、函数功能：

建立备用链表*/

voidInitSpace（SLinkListL）

{

inti;

for（i=0;i

{

L[i].cur=i+1;//下标为0的数组元素的游标指向备用链表的第一个结点，下标为1的那个结点（全空的）

}

L[MAXSIZE-1].cur=0;//最后一个下标的数组元素的游标指向链表的第一个结点，下标为0（全空的）

}

/*

原理：

1、建立备用链表，全表为空，第一个元素的游标指向备用链表的第一个结点

2、最后一个下标的数组元素的游标指向链表的第一个结点

3、其它结点用于存储链表数据，按顺序指下去

*/

/*2、函数功能：

构造空链表；返回值：

空表在数组中的位置*/

intInitList（SLinkListL）

{

inti;

i=Malloc（L）;

L[i].cur=0;//建立一个结点

returni;

}

/*

原理：

1、使用Malloc获得一个空的结点出来

2、让这个空结点的游标为0

*/

/*3、函数功能：

链表非空就返回备用链表的第一个结点，否则返回0*/

intMalloc（SLinkListspace）

{

inti=space[0].cur;

if（i!

=0）

{

space[0].cur=space[i].cur;

}

returni;

}

/*

原理：

1、第一个元素的游标（i）指向备用链表的第一个结点，这个结点的下标（i）将作为返回值（为0时，表示备用链表没有了）

2、第一个元素的游标指向备用链表的第一个结点，现在就是备用链表的第二个结点了（不一定是i+1，是space[i].cur）

*/

/*4、函数功能：

打印进度条*/

voidScheFunc（）

{

for（inti=0;i<=100;i+=5）

{

printf（"%4d%%",i）;

printf（"\b\b\b\b\b"）;

Sleep（10）;

}

printf（"\n"）;

}

/*5、函数功能：

判断L中表头位序为n的链表是否空*/

boolListEmpty（SLinkListL,intn）

{

if（L[n].cur==0）//表头游标是0，就是空静态表了

{

returntrue;

}

else

{

returnfalse;

}

}

/*

原理；

1、表头游标是0，就是空静态表了

2、空返回true

*/

/*6、函数功能：

计算表头为n的链表的长度*/

intListLength（SLinkListL,intn）

{

intlength;

for（length=0;L[n].cur!

=0;n=L[n].cur）

{

length++;

}

returnlength;

}

/*

原理：

1、游标指向下一个结点的下标

2、最后一个结点的游标是0

*/

/*7、函数功能：

数据插入；参数：

SLinkListL：

链表；intn：

链表表头下标；inti：

插入位置；ElemTypee：

插入元素的值；*/

boolListInsert（SLinkListL,int*n,inti,ElemTypee）

{

intpos,head=*n;

if（i<1||i>ListLength（L,*n）+1）

{

returnfalse;

}

pos=Malloc（L）;

if（pos==0）

{

returnfalse;

}

L[pos].data=e;//数据域赋值

if（i==1）//插入在第一位

{

L[pos].cur=head;

*n=pos;

}

elseif（i==ListLength（L,*n）+1）//插入在最后一位

{

for（intj=1;j<=ListLength（L,*n）-1;j++）

{

head=L[head].cur;

}

L[pos].cur=L[head].cur;//最后一个元素的cur不是0，是它的下一个结点的cur是0

L[head].cur=pos;

}

else

{

for（intj=1;j

{

head=L[head].cur;

}

L[pos].cur=L[head].cur;//i的游标指向之前的i（现在的i+1）

L[head].cur=pos;//i-1指向i

}

returntrue;

}

/*

原理：

1、记录下头结点的下标，后续正常……

2、找到第i-1个结点的下标

3、插入的i与之前的i-1、i进行交接

*/

/*8、函数功能：

打印元素*/

voidVisit（ElemTypee）

{

printf（"%c\t",e）;

}

/*9、函数功能：

遍历结点并打印;n:

表示头结点下标*/

voidListTraverse（SLinkListL,intn,void（*vi）（ElemTypee））

{

inthead=n;

while（L[head].cur!

=0）

{

vi（L[head].data）;

head=L[head].cur;

}

printf（"\n"）;

}

/*10、函数功能：

清空链表，转化到备用链表去*/

intClearList（SLinkListL,intn）

{

/*将备用链表的头结点接到原链表的尾巴上，L[0].cur指向原链表的头结点*/

inti,j;

i=L[n].cur;//原链表的头结点

L[0].cur=i;//指向原第一个结点，头结点还是n

j=L[0].cur;//备用链表的头结点

L[n].cur=0;//结束标志

while（L[i].cur!

=0）

{

i=L[i].cur;

}

L[i].cur=j;

return0;

}

/*

原理：

1、找到备用链表的第一个结点，原链表的最后一个结点

2、将备用链表的第一个结点接在原链表的最后一个结点上

3、修改L[0].cur

4、L[MAX-1].cur不用修改，头结点任然还是n

5、这只是将La链表接到备用链表上去了，没有影响Lb链表

*/

/*11、函数功能：

获取对应位置的元素；*/

intGetElem（SLinkListL,intn,intpos,ElemType&e）

{

inti,j;

j=n;

if（pos<1||pos>ListLength（L,n））

{

return-1;

}

for（i=1;i<=pos;i++）

{

e=L[j].data;

j=L[j].cur;

}

return0;

}

/*

原理；

1、判断获得位置在不在链表的范围

2、在对应位置取元素

*/

/*12、函数功能：

通过元素查询第一次位置*/

intLocateElem（SLinkListL,intn,ElemTypee）

{

inthead=n,flage=0,count=0;

while（L[head].cur!

=0）

{

count++;

if（L[head].data==e）

{

flage=1;

break;

}

head=L[head].cur;

}

if（flage==1）

{

returncount;

}

else

{

return-1;

}

}

/*

原理：

1、获得头节点下标

2、变量对位置进行计数

3、判断元素值

4、返回结果

*/

/*13、函数功能：

查找e的前驱元素*/

intPriorElem（SLinkListL,intn,intpos,ElemType&e0,ElemType&e）

{

inthead=n,flag=0;

if（pos<=1||pos>ListLength（L,n））

{

return-1;

}

for（inti=1;i

{

e0=L[head].data;

head=L[head].cur;

}

e=L[head].data;

return0;

}

/*

原理；

1、传入位置

2、判断

3、循环，e0是前驱，e是pos上的元素

*/

/*14、函数功能：

查找e的后继元素*/

intNextElem（SLinkListL,intn,intpos,ElemType&e0,ElemType&e）

{

inthead=n;

if（pos<1||pos>=ListLength（L,n））

{

return-1;

}

for（inti=1;i

{

head=L[head].cur;

}

e=L[head].data;

e0=L[L[head].cur].data;

return1;

}

/*

1、传入位置

2、判断

3、循环，e0是后继，e是pos上的元素

*/

/*15、函数功能：

删除元素;n:

表头，i：

删除的位置*/

intListDelete（SLinkListL,int&n,inti,ElemType*e）

{

intk,j=n,temp;

if（i<1||i>ListLength（L,n））

{

return-1;

}

//到达i-1

if（i==1）

{

*e=L[j].data;

n=L[j].cur;

}

elseif（i==ListLength（L,n））

{

for（k=0;k

{

j=L[j].cur;

}

temp=L[j].cur;

*e=L[temp].data;

L[j].cur=0;

j=temp;

}else

{

for（k=0;k

{

j=L[j].cur;

}

//i-1-->i+1

temp=L[j].cur;

L[j].cur=L[L[j].cur].cur;

//i

j=temp;

*e=L[j].data;

}

//释放i

Free（L,j）;

return0;

}

/*

原理：

1、传入参数，进行判断

2、分三类进行删除，注意顺序代码

4、得到i的元素值，并释放i位置的结点

*/

/*16、函数功能：

把不用的结点放到备用链表；k不用结点的下标*/

voidFree（SLinkListL,intk）

{

L[k].cur=L[0].cur;

L[0].cur=k;

}

/*

原理：

1、i指向之前的备用链表的头结点

2、L[0]指向i

*/

intmain（）

{

inttemp,La,Lb,j,cou=1,i;

ElemTypee,e0;

SLinkListL,s;

//1、建立备用链表

printf（"下面将建立备用链表……"）;

ScheFunc（）;

InitSpace（L）;

printf（"建立备用链表完成!

\n\n"）;

printf（"**************************************【%d】*************************************\n\n",cou++）;

//2、初始化链表La

printf（"下面将初始化链表La……"）;

ScheFunc（）;

La=InitList（L）;

printf（"初始化链表La完成!

\n\n"）;

printf（"**************************************【%d】*************************************\n\n",cou++）;

//3、初始化链表Lb

printf（"下面将初始化链表Lb……"）;

ScheFunc（）;

Lb=InitList（L）;

printf（"初始化链表Lb完成!

\n\n"）;

printf（"**************************************【%d】*************************************\n\n",cou++）;

//4、判断La链表是否为空、并求得链表长度

printf（"下面将判断La链表是否为空、并求得链表长度……"）;

ScheFunc（）;

if（ListEmpty（L,La））

{

printf（"这是一个空链表：

"）;

}

else

{

printf（"链表非空：

"）;

}

printf（"表长为%d\n",ListLength（L,La））;

printf（"判断La是否为空完成!

计算La长度完成!

\n\n"）;

printf（"**************************************【%d】*************************************\n\n",cou++）;

//5、将La表进行插入

printf（"下面将La表进行插入……\n"）;

ScheFunc（）;

for（i=0;i<5;i++）

{

ListInsert（L,&La,ListLength（L,La）+1,i+'a'）;

}

printf（"插入完成……\n"）;

printf（"La表长为%d\n",ListLength（L,La））;

printf（"下面打印La链表元素……\n"）;

ListTraverse（L,La,Visit）;

printf（"**************************************【%d】*************************************\n\n",cou++）;

//6、将Lb表进行插入

printf（"下面将Lb表进行插入……\n"）;

ScheFunc（）;

for（i=3;i<10;i++）

{

ListInsert（L,&Lb,ListLength（L,Lb）+1,i+'a'）;

}

printf（"插入完成……\n"）;

printf（"Lb表长为%d\n",ListLength（L,Lb））;

printf（"下面打印Lb链表元素……\n"）;

ListTraverse（L,Lb,Visit）;

printf（"**************************************【%d】*************************************\n\n",cou++）;

//7、将进行La链表清空

printf（"下面将进行La链表清空……\n"）;

ClearList（L,La）;

printf（"La清空完成……\n"）;

printf（"La表长为%d\n",ListLength（L,La））;

printf（"**************************************【%d】*************************************\n\n",cou++）;

//8、进行Lb取元素操作

printf（"下面将进行Lb取元素操作……\n"）;

ListTraverse（L,Lb,Visit）;

for（j=1;j<20;j+=2）

{

temp=GetElem（L,Lb,j,e）;

if（temp!

=-1）

{

printf（"Lb链表%d位置上的元素是%c\n",j,e）;

}

else

{

printf（"Lb不存在%d这个位置上的元素\n",j）;

}

}

printf（"Lb取元素操作完成……\n"）;

printf（"**************************************【%d】*************************************\n\n",cou++）;

//9、进行Lb查位置

printf（"下面将进行Lb查位置操作……\n"）;

ListTraverse（L,Lb,Visit）;

for（e='a';e<='z';e+=3）

{

temp=LocateElem（L,Lb,e）;

if（temp!

=-1）

{

printf（"Lb链表元素%c所在位置是%d\n",e,temp）;

}

else

{

printf（"Lb不存在%c这个元素\n",e）;

}

}

printf（"Lb查位置操作完成……\n"）;

printf（"**************************************【%d】*************************************\n\n",cou++）;

//10、查询某个位置元素的前驱

printf（"下面将进行Lb查前驱操作……\n"）;

ListTraverse（L,Lb,Visit）;

for（j=1;j<=10;j++）

{

temp=PriorElem（L,Lb,j,e0,e）;

if（temp!

=-1）

{

printf（"Lb链表中%d位上的元素%c的前驱是%c\n",j,e,e0）;

}

else

{

printf（"Lb中%d位上没有前驱\n",j）;

}

}

printf（"Lb查前驱操作完成……\n"）;

printf（"**************************************【%d】************************************\n\n",cou++）;

//11、查询某个位置元素的后继

printf（"下面将进行Lb查后继操作……\n"）;

ListTraverse（L,Lb,Visit）;