C语言静态链表Word文档格式.docx

C语言静态链表Word文档格式.docx

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

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&

/*13、函数功能：

查找e的前驱元素*/

intNextElem（SLinkListL,intn,intpos,ElemType&

e0,ElemType&

/*14、函数功能：

查找e的后继元素*/

intListDelete（SLinkListL,int&

n,inti,ElemType*e）;

/*15、函数功能：

删除元素;

表头，i：

删除的位置*/

voidFree（SLinkListL,intk）;

/*16、函数功能：

把不用的结点放到备用链表；

k不用结点的下标*/

/*1、函数功能：

voidInitSpace（SLinkListL）

inti;

for（i=0;

i<

MAXSIZE-1;

i++）

{

L[i].cur=i+1;

//下标为0的数组元素的游标指向备用链表的第一个结点，下标为1的那个结点（全空的）

}

L[MAXSIZE-1].cur=0;

//最后一个下标的数组元素的游标指向链表的第一个结点，下标为0（全空的）

}

/*

原理：

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

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

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

/*2、函数功能：

intInitList（SLinkListL）

i=Malloc（L）;

L[i].cur=0;

//建立一个结点

returni;

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

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

/*3、函数功能：

intMalloc（SLinkListspace）

inti=space[0].cur;

if（i!

=0）

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

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

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

/*4、函数功能：

voidScheFunc（）

for（inti=0;

=100;

i+=5）

printf（"

%4d%%"

i）;

\b\b\b\b\b"

）;

Sleep（10）;

printf（"

\n"

/*5、函数功能：

boolListEmpty（SLinkListL,intn）

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

returntrue;

else

returnfalse;

原理；

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

2、空返回true

/*6、函数功能：

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）

pos=Malloc（L）;

if（pos==0）

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;

i-1;

//i的游标指向之前的i（现在的i+1）

//i-1指向i

returntrue;

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

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

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

/*8、函数功能：

voidVisit（ElemTypee）

%c\t"

e）;

/*9、函数功能：

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

inthead=n;

while（L[head].cur!

vi（L[head].data）;

head=L[head].cur;

/*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!

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）

j=n;

if（pos<

1||pos>

ListLength（L,n））

return-1;

for（i=1;

=pos;

e=L[j].data;

j=L[j].cur;

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

2、在对应位置取元素

/*12、函数功能：

intLocateElem（SLinkListL,intn,ElemTypee）

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

count++;

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

flage=1;

break;

if（flage==1）

returncount;

1、获得头节点下标

2、变量对位置进行计数

3、判断元素值

4、返回结果

/*13、函数功能：

inthead=n,flag=0;

=1||pos>

ListLength（L,n））

for（inti=1;

pos;

e0=L[head].data;

e=L[head].data;

1、传入位置

2、判断

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

/*14、函数功能：

inthead=n;

if（pos<

1||pos>

=ListLength（L,n））

for（inti=1;

pos;

i++）

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

return1;

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

/*15、函数功能：

n,inti,ElemType*e）

intk,j=n,temp;

//到达i-1

if（i==1）

*e=L[j].data;

n=L[j].cur;

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

for（k=0;

k<

i-2;

k++）

j=L[j].cur;

temp=L[j].cur;

*e=L[temp].data;

L[j].cur=0;

j=temp;

}else

i-2;

//i-1-->

i+1

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

//i

//释放i

Free（L,j）;

1、传入参数，进行判断

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

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

/*16、函数功能：

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、建立备用链表

下面将建立备用链表……"

ScheFunc（）;

InitSpace（L）;

建立备用链表完成!

\n\n"

**************************************【%d】*************************************\n\n"

cou++）;

//2、初始化链表La

下面将初始化链表La……"

La=InitList（L）;

初始化链表La完成!

cou++）;

//3、初始化链表Lb

下面将初始化链表Lb……"

Lb=InitList（L）;

初始化链表Lb完成!

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

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

if（ListEmpty（L,La））

这是一个空链表：

"

链表非空：

表长为%d\n"

ListLength（L,La））;

判断La是否为空完成!

计算La长度完成!

//5、将La表进行插入

下面将La表进行插入……\n"

5;

ListInsert（L,&

La,ListLength（L,La）+1,i+'

a'

插入完成……\n"

La表长为%d\n"

ListLength（L,La））;

下面打印La链表元素……\n"

ListTraverse（L,La,Visit）;

//6、将Lb表进行插入

下面将Lb表进行插入……\n"

for（i=3;

10;

Lb,ListLength（L,Lb）+1,i+'

Lb表长为%d\n"

ListLength（L,Lb））;

下面打印Lb链表元素……\n"

ListTraverse（L,Lb,Visit）;

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

下面将进行La链表清空……\n"

ClearList（L,La）;

La清空完成……\n"

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

下面将进行Lb取元素操作……\n"

for（j=1;

20;

j+=2）

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

if（temp!

=-1）

printf（"

Lb链表%d位置上的元素是%c\n"

j,e）;

else

Lb不存在%d这个位置上的元素\n"

j）;

Lb取元素操作完成……\n"

//9、进行Lb查位置

下面将进行Lb查位置操作……\n"

for（e='

;

e<

='

z'

e+=3）

temp=LocateElem（L,Lb,e）;

Lb链表元素%c所在位置是%d\n"

e,temp）;

Lb不存在%c这个元素\n"

e）;

Lb查位置操作完成……\n"

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

下面将进行Lb查前驱操作……\n"

for（j=1;

=10;

j++）

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

Lb链表中%d位上的元素%c的前驱是%c\n"

j,e,e0）;

Lb中%d位上没有前驱\n"

Lb查前驱操作完成……\n"

**************************************【%d】************************************\n\n"

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

下面将进行Lb查后继操作……\n"