线性表的静态单链表存储结构

/*
借用一维数组来描述线性链表 
—————— 线性表的静态单链表存储结构——————
#define MAXSIZE 1000 //链表的最大长度
typedef struct 
{
	ElemType data;
	int cur;
}component,SLinkList[MAXSIZE];
这种描述方法便于不设“指针”类型的高级程序设计语言中使用链表结构 
如上描述的链表中，数组的一个分量表示一个结点，同时用游标（指示器cur）代替指针指示结点在数组中的相对位置
数组的第零分量可看成头结点，其指针域指示链表的第一个结点
这种存储结构仍需要预先分配一个较大的空间，但在线性链表的插入和删除操作时不需要移动元素，
仅需修改指针（cur),仍具有链式存储结构的优点，把这种用数组描述的链表起名叫 静态链表
*/

#include <stdio.h>

#define MAXSIZE 100 //链表的最大长度
typedef struct 
{
	int data;
	int cur;
}component,SLinkList[MAXSIZE];

void InitList(SLinkList L); //构造一个空的链表

//以下两个函数被函数ListInsert()调用
int Malloc(SLinkList space); 
int ListLength(SLinkList L); //返回L中数据元素的个数
bool ListInsert(SLinkList L,int i,int e); //在L中第i个元素之前插入新的数据元素e 

bool ListTraverse(SLinkList L); //输出线性表的数据
void ListEmpty(SLinkList L); //判断线性表是否为空
bool ClearList(SLinkList L); //将L置为空表
bool GetElem(SLinkList L,int i,int *e); //用e返回L中第i元素的值
int LocateElem(SLinkList L,int e);
bool PriorElem(SLinkList L,int cur_e,int *pre_e); 
bool NextElem(SLinkList L,int cur_e,int *next_e);
void Free(SLinkList space,int k);
bool ListDelete(SLinkList L,int i,int *e);

int main()
{
	int j, k;
	int e, e0;
	SLinkList L;
	InitList(L);
	for(j = 1; j <= 5; j++)
		ListInsert(L,1,j);
	printf("在L的表头依次插入1-5后：L = ");
	ListTraverse(L);
	
	ListEmpty(L); //判断L是否为空 
	printf("len = %d\n",ListLength(L));

	ClearList(L); //清空链表
	ListEmpty(L); //判断L是否为空

	for(j = 1; j <= 10; j++)
		ListInsert(L,j,j);
	printf("在L的表中依次插入1-10后：L = ");
	ListTraverse(L);

	GetElem(L,5,&e);//把第5个元素赋给 e
	printf("第5个元素的值为：%d\n",e);

	for(j = 1; j <= 10; j++)
	{
		k = LocateElem(L,j);
		if(k)
			printf("值为%d的元素在静态链表中的位序为%d\n",j,k);
		else
			printf("没有值为%d的元素\n",j);
	}

	for(j = 1; j <= 2; j++) //测试头两个数据
	{
		GetElem(L,j,&e0); //把第j个数据赋给e0
		PriorElem(L,e0,&e); //求e0的前驱
		if( PriorElem(L,e0,&e) )
			printf("元素%d的前驱为：%d\n",e0,e);
		else
			printf("元素%d无前驱\n",e0);
	}

	for(j = ListLength(L) - 1; j <= ListLength(L); j++) //最后两个数据
	{
		GetElem(L,j,&e0); //把第j个元素赋给e0;
		NextElem(L,e0,&e); //求e0的后继
		if( NextElem(L,e0,&e) )
			printf("元素%d的后继为：%d\n",e0,e);
		else
			printf("元素%d无后继\n",e0);
	}

	k = ListLength(L); //k为表长
	ListDelete(L,k,&e);
	printf("删除的元素为: %d\n",e);
	ListDelete(L,k-1,&e);
	printf("删除的元素为: %d\n",e);
	printf("依次输出L的元素：");
	ListTraverse(L); //输出元素的值

	return 0;
}

void InitList(SLinkList L) //构造一个空的链表
{	//表头为L的最后一个单元L[MAXSIZE-1] ,其余单元链成一个
	//备用链表，表头为L的第一个单元L[0].cur, "0"表示空指针
	int i;
	L[MAXSIZE-1].cur = 0; //L的最后一个单元为空链表的表头
	for(i = 0; i < MAXSIZE - 2; i++) //将其余单元链接成以L[0]为表头的备用链表
		L[i].cur = i + 1;
	L[MAXSIZE-2].cur = 0;
}

bool ListInsert(SLinkList L,int i,int e) //在L中第i个元素之前插入新的数据元素e 
{
	int l, j, k = MAXSIZE - 1; //k指向表头
	if(i < 1 || i > ListLength(L) + 1)
		return false;
	j = Malloc(L); //申请新单元
	if(j) //申请成功
	{
		L[j].data = e; //赋值给新单元
		for(l = 1; l < i; l++) //移动第i-1个元素
			k = L[k].cur;
		L[j].cur = L[k].cur;
		L[k].cur = j;
		return true;
	}
	return false;
}

int ListLength(SLinkList L) //返回L中数据元素的个数
{
	int j = 0, i = L[MAXSIZE-1].cur; //i指向第一个元素
	while(i) //没到静态链表尾
	{
		i = L[i].cur; //指向下一个元素
		j++;
	}
	return j;
}

int Malloc(SLinkList space)
{	//若备用链表非空，则返回分配的结点下标（备用链表的第一个结点），否则返回 0
	int i = space[0].cur;
	if(i) //备用链表非空
		space[0].cur = space[i].cur; //备用链表的头节点指向原备用链表的第二个结点
	return i; //返回
}

bool ListTraverse(SLinkList L) //输出线性表的数据
{
	int i = L[MAXSIZE-1].cur; //指向第一个元素
	while(i) //没有到静态链表尾
	{
		printf("%d ",L[i].data);
		i = L[i].cur; //指向下一个元素
	}
	printf("\n");
	return true;
}

void ListEmpty(SLinkList L) //判断线性表是否为空
{
	if(L[MAXSIZE-1].cur == 0) //表为空
		printf("链表为空\n");
	else
		printf("链表不为空\n");
}

bool ClearList(SLinkList L) //将L置为空表       
{
	int i, j, k;
	i = L[MAXSIZE-1].cur; //链表第一个结点的位置
	L[MAXSIZE-1].cur = 0; //链表空
	k = L[0].cur; //备用链表第一个结点的位置
	L[0].cur = i; // 把链表的结点连接到备用链表的表头
	while(i) //没有到表尾
	{
		j = i;
		i = L[i].cur; //指向下一个元素
	}
	L[j].cur = k; //备用链表的第一个结点连接到链表的尾部
	return true;
}

bool GetElem(SLinkList L,int i,int *e) //用e返回L中第i元素的值
{
	int l,k = MAXSIZE - 1; //K指向表头序号
	if(i < 1|| i > ListLength(L))
		return false;
	for(l = 1; l <= i; l++) //移动到第i个元素处
		k = L[k].cur;
	*e = L[k].data;
	return true;
}

int LocateElem(SLinkList L,int e)
{
	//在静态单链线性表L中查找第i个值为e的元素 若找到，则返回它在L中的位序 
	int i = L[MAXSIZE-1].cur; //i指示表中第一个结点
	while(i && L[i].data != e) //在表中顺序查找
		i = L[i].cur;
	return i;
}

bool PriorElem(SLinkList L,int cur_e,int *pre_e)
{
	// 若cur_e是L的数据元素，且不是第一个 则用pre_e返回它的前驱
	int j, i = L[MAXSIZE-1].cur; //i指示链表第一个结点的位置
	do
	{
		//向后移动结点
		j = i;
		i = L[i].cur;
	}while(i && cur_e != L[i].data);
	if(i) //找到该元素
	{
		*pre_e = L[j].data;
		return true;
	}
	return false;
}

bool NextElem(SLinkList L,int cur_e,int *next_e)
{
	//若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继
	int j, i = LocateElem(L,cur_e); //在L中查找第一个值为cur_e元素的位置
	if(i) //L中存在cur_e
	{
		j = L[i].cur; //cur_e的后继位置
		if(j) //cur_e有后继
		{
			*next_e = L[j].data;
			return true; //cur_e元素有后继
		}
	}
	return false;
}

bool ListDelete(SLinkList L,int i,int *e)
{
	//删除在L中第i个数据元素e 并返回其值
	int j, k = MAXSIZE - 1;
	if(i < 1 || i > ListLength(L))
		return false;
	for(j = 1; j < i; j++) //移动 i- 1 个元素
		k = L[k].cur;
	j = L[k].cur;
	L[k].cur = L[j].cur;
	*e = L[j].data;
	Free(L,j);
	return true;
}

void Free(SLinkList space,int k)
{
	//将下标为k的空闲结点回收到备用链表
	space[k].cur = space[0].cur; //回收结点的“游标”指向备用链表的第一个结点
	space[0].cur = k; //备用链表的头结点指向新的收点
}

程序执行结果：