数据结构与算法之线性表（静态链表）

 

静态链表

静态链表是用数组描述的链表，这种描述的方法叫游标实现法
 

 

线性表的静态链表存储如图：

 

 

如上图：数组模拟的静态链表有两个元素，一个保存数据和一个保存游标

这里有几个特殊的地方：

（1）静态链表的头和尾都不保存数据

（2）第一个结点的游标存放数组中第一个没有数据的下标

（3）最后一个元素的游标存放第一个有数据的下标，也就是数组的第二个元素，下标为1

（4）从第一个有数据的元素开始，游标存放的是下一个元素的下标，依次类推，形成链表的形式

（5）最后一个有数据的游标为0

 

静态链表的数据结构：

/*
*静态链表的定义
*/

#include <stdlib.h>
#include <malloc.h>
#define MAXSIZE 1000
typedef int ElemType;

typedef struct 
{
	ElemType data;//数据
	int cur;//游标
}Componet,StaticList[MAXSIZE];

 

对静态链表进行初始化相当于初始化数组

 

/*
*静态链表的定义
*/

#include <stdlib.h>
#include <malloc.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 1000
typedef int ElemType;

typedef struct 
{
	ElemType data;//数据
	int cur;//游标
}Componet,StaticList[MAXSIZE];

//初始化静态链表
Componet initList(StaticList space)
{
	int i;
	for ( i = 0; i < MAXSIZE; i++)
	{
		space[i].cur = i + 1;
	}
	space[MAXSIZE - 1].cur = 0;
	return OK;
}

 

静态链表的定义生成总结：

--对数组的第一个和最后一个元素做特殊处理，他们的data存放数据

--通常把未使用的数组元素（无数据）称为备用链表

--数组的第一个元素，即下标为0的元素的cur就存放备用链表的第一个结点的下标

--数组的最后一个元素，即下标为MAXSIZE-1的cur则存放第一个有数值的元素的下标，相当于单链表中的头结点的作用

 

 

 

静态链表的插入和删除操作

 

--在静态链表中，我们操作的是数组，不存在像动态链表的结点申请和释放的问题，所以我们需要自己实现这两个函数，才能做到插入和删除操作

--解决的办法是将所有未被使用过的和以及被删除的游标链成一个备用链表

 

（1）静态链表的插入操作

 

/*
*静态链表的定义
*/

#include <stdlib.h>
#include <malloc.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 1000
typedef int ElemType;
typedef int Stu;

typedef struct 
{
	ElemType data;//数据
	int cur;//游标
}Componet,StaticList[MAXSIZE];

//初始化静态链表
Stu initList(StaticList space)
{
	int i;
	for ( i = 0; i < MAXSIZE; i++)
	{
		space[i].cur = i + 1;
	}
	space[MAXSIZE - 1].cur = 0;
	return OK;
}

//获取空闲元素（无数据的）下标
int malloc_i(StaticList space)
{
	int i = space[0].cur;//第一元素的游标存放的就是第一个空元素的下标
	if (space[0].cur)//如果space[0].cur不为0
	{
		space[0].cur = space[i].cur;//就接着把i位置的游标再给第一个元素的游标
	}
	return i;
}

//静态链表的插入
Stu insertList(StaticList L,int i ,ElemType e)
{
	int k,j,m;
	k = MAXSIZE - 1;//最后一个元素的下标
	if (i<1 || i>StaticList(L) - 1)
	{
		return ERROR;
	}

	j = malloc_i(L);
	if (j)
	{
		L[j].data = e;
		for (m = 1; m <= i - 1; m++)
		{
			k = L[k].cur;//把最后一元素的游标
		}
	}
	L[j].cur = L[k].cur;
	L[k].cur = j;
	return OK;
}

 

 

 

 

（2）静态链表的删除

 

//静态链表的删除
Stu DeleteList(StaticList L, int i)
{
	int k, j;
	k = MAXSIZE - 1;//最后一个元素的下标
	if (i<1 || i>StaticList(L) - 1)
	{
		return ERROR;
	}
	for (j = 1; j <= i - 1; j++)
	{
		k = L[k].cur;//把最后一元素的游标
	}

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

	Pree_i(L, j);//把删除的元素加入到未使用的链表中

	return OK;
}

//把删除的元素加入到未使用的链表中
void Pree_i(StaticList L, int i)
{
	L[i].cur = L[0].cur;
	L[0].cur = i;
}

 

（3）返回静态链表的元素个数

 

//返回L中数据元素的个数
int ListLength(StaticList L)
{
	int j = 0;
	int i = L[MAXSIZE - 1].cur;

	while (i)
	{
		i = L[i].cur;
		j++;
	}
	return j;
}

 

静态链表的优点和缺点：

优点

--在插入和删除操作，只需要修改游标，不需要移动元素，从而改进了在顺序存储结构中插入和删除操作需要移动大量元素的缺点

缺点

--没有解决连续存储分配（数组）带来的表长难以确定的问题

--失去了顺序存储结构随机存取的特性