数据结构-线性表-静态链表完整可执行代码（c语言描述）
/***************************************************************************
*
* 静态链表
* ADT (List)
* Data
* {a1, a2, a3, ..., an}
* Operation
* InitList(*L); 初始化静态链表L.
* ListEmpty(L); 静态链表L,返回true,否则返回false.
* ClearList(*L); 将单链表L清空.
* GetElem(L, i, *e); 将单链表L中第i个位置元素值返回给e.
* LocateElem(L, e); 在L查找和e相等的元素,成功返回元素所在的.
* 序号,否则,返回0表示失败.
* ListInsert(*L, i, e); 在L中第i个位置插入新元素e.
* ListDelete(*L, i); 删除L中第i个位置的元素.
* ListLength(L); 返回线性表L的元素个数.
* ENDADT
*
* 逻辑结构
* 0|a0| m| ----> 备用链表头指针
* 1|a1| 2|
* 2|a2| 3|
* .. ..
* i|ai| 0|
* .. ..
* max-1|an| 1| ----> 链表头指针
*
* 修改记录：
* 2012-12-11 重新组织代码,编译调试，修正语法错误.
*/
/************************ data 静态链表存储结构定义 *********************/
#define MAXSIZE 1000 /* 假设链表最大的长度为1000 */
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int ElemType; /* ElemType 类型根据实际情况而定,现假设为 int */
typedef int Status; /* Status 是函数的类型，其值是函数结果状态代码 */
/* 静态链表存储结构 */
typedef struct{
ElemType data;
int cur; /* 游标(cursor) 为0 时表示无指向 */
}Component, StaticLinkList[MAXSIZE];
/***************************** operation 操作 *****************************/
/*
* 初始条件：静态链表L不存在。
* 操作结果：将一维数组space中各个分量链成一备用链表
* 数组第一个元素的游标cur用来存放备用链表第一个节点的下标。
* 数组最后一个元素的游标cur存放第一个有数值元素的下标，相当
* 于单链表的头节点。
*/
Status InitList(StaticLinkList space)
{
int i;
for(i = 0; i < MAXSIZE - 1; i++){
space[i].cur = i + 1;
}
space[MAXSIZE - 1].cur = 0; /* 目前静态链表为空，最后一个元素的cur 为0 */
return OK;
}
/*
* 初始条件：静态链表L已存在
* 操作结果：如果静态链表为空，返回true，否则返回false
*/
Status ListEmpty(StaticLinkList L)
{
return (ListLength(L) == 0 ? TRUE : FALSE);
}
/* 若备用空间链表非空，则返回分配的节点下标，否则返回0 */
int Malloc_SLL(StaticLinkList space)
{
int i = space[0].cur; /* 当前数组第一元素的cur存的值，
就是要返回第一个备用空闲的下标. */
/* 由于要拿出一个分量来使用了，所以需要
把它的下一个分量用来做准备 */
if(space[0].cur)
space[0].cur = space[i].cur;
return i;
}
/*
* 初始条件: 静态链表L已存在
* 操作结果：将静态链表L元素清空为0，长度置为0
* 备用链表置为初始状态
*/
void ClearList(StaticLinkList L)
{
int i;
i = L[MAXSIZE - 1].cur;
while(i){
L[i].data = 0;
ListDelete(L,i);
}
}
/*
* 初始条件：静态链表L已存在，1 <= i <= ListLength(L)
* 操作结果：用e返回L中第i个元素的值
*/
Status GetElem(StaticLinkList L, int i, ElemType *e)
{
int j;
int k;
j = L[MAXSIZE - 1].cur;
k = 1;
while(j && k < i){
j = L[j].cur;
k++;
}
if(!j || k > i)
return ERROR;
*e = L[j].data;
return OK;
}
/*
* 初始条件：静态链表L已存在.
* 操作结果：在L查找和e相等的元素，成功返回元素所在的序号，
* 否则，返回0表示失败
*/
Status LocateElem(StaticLinkList L, ElemType e)
{
int i = L[MAXSIZE - 1].cur;
while(i){
if (L[i].data == e)
return i;
i = L[i].cur;
}
return 0;
}
/*
* 初始条件: 静态链表L已存在，1 <= i <= ListLength(L)
* 操作结果：在L中第i个位置之前插入新元素e , L的长度加1
*/
Status ListInsert(StaticLinkList L, int i, ElemType e)
{
int j;
int k;
int l;
k = MAXSIZE - 1; /* 注意k首先是最后一个元素的下标,即头指针 */
if(i < 1 || i > ListLength(L) + 1)
return ERROR;
j = Malloc_SLL(L); /* 获取空闲分量的下标 */
if(j){
L[j].data = e; /* 将数据赋给此分量的data */
for(l = 1; l <= i - 1; l++) /* 从表头开始找到第i元素之前的位置 */
k = L[k].cur;
L[j].cur = L[k].cur; /* 把第i元素之前的cur赋值给新元素的cur */
L[k].cur = j; /* 把新元素的下标赋值给第i元素之前元素的cur */
return OK;
}
return ERROR;
}
/* 将下标为k的空闲节点回收到备用链表,类似头插入法 */
void Free_SLL(StaticLinkList space, int k)
{
space[k].cur = space[0].cur; /* 把第一个元素cur值赋给要删除的分量的cur */
space[0].cur = k; /* 把要删除的元素的下标赋给头指针cur */
}
/*
* 初始条件: 静态链表L已存在，1 <= i <= ListLength(L)
* 操作结果：删除在L中第i个元素e.
*/
Status ListDelete(StaticLinkList L, int i)
{
int j;
int k;
if (i < 1 || i > ListLength(L))
return ERROR;
k = MAXSIZE - 1;
for(j = 1; j <= i - 1; j++){ /* 找到要删除的元素的前一个位置的下标 */
k = L[j].cur;
}
j = L[k].cur; /* 暂存要删除的元素的下标 */
L[k].cur = L[j].cur; /* 把要删除的元素的前一个元素的游标改要
删除元素的后继 */
Free_SLL(L, j);
return OK;
}
/*
* 初始条件：静态链表L已经存在.
* 操作结果：返回L的元素个数.
*/
int ListLength(StaticLinkList L)
{
int j = 0;
int i = L[MAXSIZE - 1].cur;
while(i){
i = L[i].cur;
j++;
}
return j;
}
int main()
{
// 具体操作...
// StaticLinkList L;
// InitList(L);
return 0;
}