静态链表(数据结构)

参考博客

静态链表的定义

用数组描述的链表，即称为静态链表。
在C语言中，静态链表的表现形式即为结构体数组，结构体变量包括数据域data和游标CUR。
优点：
这种存储结构，仍需要预先分配一个较大的空间，但在作为线性表的插入和删除操作时不需移动元素，仅需修改指针，故仍具有链式存储结构的主要优点。

静态链表的结构

typedef struct StaticLink{
	int data;//数据
	int cur;//用数组的索引模拟链表的指针
}StaticLinkList[MAXSIZE];

静态链表的初始化

我们对数组的第一个和最后一个元素做特殊处理，不存数据。让数组的第一个元素cur存放第一个备用元素（未被占用的元素）下标，而数组的最后一个元素cur存放第一个有值的元素下标，相当于头结点作用 。
如图：设MAXSIZE=9。

初始化代码

void InitStaticLinkList(StaticLinkList L)
{
	for (int i = 0; i < MAXSIZE - 1; i++)
	{
		L[i].cur = i + 1;//最后一个元素指向的是尾节点
	}
	//备用链表的最后一个空元素的cur指向0，这一行不能省。
	L[MAXSIZE - 1].cur = 0;
}

分配空间

新插入一个元素之后需要重新修改L[0].cur的值，代码如下

//插入元素时，分配空间的下标
int Malloc(StaticLinkList L)
{
	int i = L[0].cur;//获取可以插入的位置 
	if (i)//如果不是空表
		L[0].cur = L[i].cur;//更新L[0]为刚才插入位置的cur，用来记录当前链表新的可插入位置 
	return i;//返回可插入位置 
}

插入元素

假设链表已有元素a,b,c,d,e,如图：

现在，表头的索引是1数据是a，所以L[9- 1].cur = 1。
插入之后第一个空闲位置的索引是6，所以L[0].cur = 6。

现在我们想再第二个数据后面插入数据 “ f ”，也就是在数据 “ b ” 后面插入
1、首先读取L[0].cur的值，获取第一个可以插入的位置，于是我们将L[L[0].cur].data = ’ f '，如下图：

这时候我们发现，下图中圈起来的几个值显然是有问题的：
所以我们接下来更新这四个值。
2、
从左往右第一个数
这个很好改，显然在图中就是：

                      L[0].cur = L[6].cur = 7

那么一般情况的话就是：

                      L[0].cur = L[L[0].cur].cur

这些也就是我们在int Malloc(StaticLinkList L)中完成了的。
从左往右第二个数和第四个数
显然在图中的话就是：

				 	  L[2].cur = 6

那么换到一般情况的话，这个6好办，6 = L[0].cur嘛。
这个2就不一样了：
有人可能觉得题目是在2之后插入，那不就是L[插入位置].cur = 6么。
这里要注意，我们的插入位置的意思是链表的第二个数据之后，不是索引的第二个之后插入，因此我们要想链式链表那样 p = p->next这样来移动到插入位置。

	//找可插入的地方 
	int j = Malloc(L);//里面修改了L[0].cur,返回值是6
	//找链表头 
	int k = MAXSIZE - 1;
	if (j)
	{
		//定位到插入的位置的前一个位置k 
		for (int l = 1; l <= i - 1; l++)
		{
			k = L[k].cur;
		}
	}

k = L[k].cur;这句话相当于就是p = p->next
for循环结束后的k就是我们上文所说的2，也就是L[k].cur = j =6
而对于L[MAXSIZE - 1].cur这个值，只有头插才会影响他的值，如果是头插的话，这个for循环就不会执行，那么 k = MAXSIZE - 1，所以L[k].cur = j这句话也就是修改了L[MAXSIZE - 1].cur的值为我们新插入的值的索引。
从左往右第三个数
有了上文的基础，第三个数自然就是

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

所以最后整体的插入代码如下图：

//静态链表中i位置插入一个元素
int StaticLinkListInsert(StaticLinkList L, int i, int key)
{
	//判断插入点是否合理
	if (i<1 || i>StaticLinkListLength(L)+1)
	{
		return false;
	}
	//找可插入的地方 
	int j = Malloc(L);//！！！修改了上文说的第一个数
	//找链表头 
	int k = MAXSIZE - 1;
	if (j)
	{
		//定位到插入的位置的前一个位置k 
		for (int l = 1; l <= i - 1; l++)
		{
			k = L[k].cur;
		}
		//插入操作 
		L[j].data = key;
		L[j].cur = L[k].cur;//！！！修改上文说的第三个数
		L[k].cur = j;//！！！修改上文说的第二第四个数
		return true;
	}
	return false;
}

结果如下图：

释放节点

void Free(StaticLinkList L, int k)
{
	L[k].cur = L[0].cur;
	L[0].cur = k;
}

删除元素

//删除第i个元素
 
bool StaticLinkListDelete(StaticLinkList L,int i, int *key)
{
	if (i < 1 || i >= StaticLinkListLength(L))
	{
		return false;
	}
	//找链表头 
	int k = MAXSIZE - 1;
	//定位到删除的地方的前一个 
	for (int l = 1; l <= i-1; l++)
	{
		k = L[k].cur;
	}
	int j = L[k].cur;
	*key = L[j].data;
	L[k].cur = L[j].cur;
	Free(L, j);
	return true;
}

遍历

//遍历
void StaticLinkListTraverse(StaticLinkList L)
{
	int k = MAXSIZE - 1;
	while (L[k].cur)
	{
		k = L[k].cur;
		printf("%d ", L[k].data);
	}
	printf("\n");
}

获取静态链表长

//求静态链表中元素个数，不包括头尾节点
int StaticLinkListLength(StaticLinkList L)
{
	int i = L[MAXSIZE - 1].cur;
	int j = 0;
	while (i)
	{
		j++;
		i = L[i].cur;
	}
	return j;
}

整体测试代码

#include<stdio.h>
 
#define MAXSIZE 7
#define true 1
#define false 0
//https://blog.csdn.net/hhhhhyyyyy8/article/details/81027728

/*
对于没有指针的编程语言，可以用数组替代指针，来描述链表。让
数组的每个元素由data和cur两部分组成，其中cur相当于链表的next
指针，这种用数组描述的链表叫做静态链表 
*/ 

/*
我们对数组的第一个和最后一个元素做特殊处理，不存数据。让数组
的第一个元素cur存放第一个备用元素（未被占用的元素）下标，而数
组的最后一个元素cur存放第一个有值的元素下标，相当于头结点作用 
*/ 
typedef struct StaticLink{
	int data;
	int cur;
}StaticLinkList[MAXSIZE];
 
void InitStaticLinkList(StaticLinkList L)
{
	for (int i = 0; i < MAXSIZE - 1; i++)
	{
		L[i].cur = i + 1;//最后一个元素指向的是尾节点
	}
	//备用链表的最后一个空元素的cur指向0，这一行不能省。
	L[MAXSIZE - 1].cur = 0;
}
 
 
//求静态链表中元素个数，不包括头尾节点
int StaticLinkListLength(StaticLinkList L)
{
	int i = L[MAXSIZE - 1].cur;
	int j = 0;
	while (i)
	{
		j++;
		i = L[i].cur;
	}
	return j;
}
 
//插入元素时，分配空间的下标
int Malloc(StaticLinkList L)
{
	int i = L[0].cur;//获取可以插入的位置 
	if (i)
		L[0].cur = L[i].cur;//更新L[0]为刚才插入位置的cur，用来记录当前链表新的可插入位置 
	return i;//返回可插入位置 
}
 
 
//静态链表中i位置插入一个元素
int StaticLinkListInsert(StaticLinkList L, int i, int key)
{
	//判断插入点是否合理
	if (i<1 || i>StaticLinkListLength(L)+1)
	{
		return false;
	}
	//找可插入的地方 
	int j = Malloc(L);
	//找链表头 
	int k = MAXSIZE - 1;
	if (j)
	{
		//定位到插入的位置的前一个位置k 
		for (int l = 1; l <= i - 1; l++)
		{
			k = L[k].cur;
		}
		//插入操作 
		L[j].data = key;
		L[j].cur = L[k].cur;
		L[k].cur = j;
		return true;
	}
	return false;
	
}
 
 
void Free(StaticLinkList L, int k)
{
	L[k].cur = L[0].cur;
	L[0].cur = k;
}
 
//删除第i个元素
 
bool StaticLinkListDelete(StaticLinkList L,int i, int *key)
{
	if (i < 1 || i >= StaticLinkListLength(L))
	{
		return false;
	}
	//找链表头 
	int k = MAXSIZE - 1;
	//定位到删除的地方的前一个 
	for (int l = 1; l <= i-1; l++)
	{
		k = L[k].cur;
	}
	int j = L[k].cur;
	*key = L[j].data;
	L[k].cur = L[j].cur;
	Free(L, j);
	return true;
}
 
//遍历
void StaticLinkListTraverse(StaticLinkList L)
{
	int k = MAXSIZE - 1;
	while (L[k].cur)
	{
		k = L[k].cur;
		printf("%d ", L[k].data);
	}
	printf("\n");
}
 
int main(void)
{
	StaticLinkList L;
	printf("初始化链表:\n");
	InitStaticLinkList(L);
	printf("初始化链表之后，链表的长度为:%d\n", StaticLinkListLength(L));
	printf("插入1,2,3,4,5\n");
	StaticLinkListInsert(L, 1, 1);
	StaticLinkListInsert(L, 1, 2);
	StaticLinkListInsert(L, 1, 3);
	StaticLinkListInsert(L, 1, 4);
	StaticLinkListInsert(L, 1, 5);
	printf("遍历链表:\n");
	StaticLinkListTraverse(L);
	printf("链表长度为:%d\n", StaticLinkListLength(L));
	printf("删除第二个元素:\n");
	int key;
	StaticLinkListDelete(L, 2, &key);
	printf("删除的元素值为:%d\n", key);
	printf("遍历链表:\n");
	StaticLinkListTraverse(L);
 
}

输出结果