静态链表学习

静态链表

   　　定义：用数组描述的链表叫做静态链表，即游标实现法。

　　　对数组的第一个和最后一个元素做特殊处理。不存数据。数组的第一个元素，即下标为0元素的cur(游标)就存放备用链表的第一个结点的下标，如果满了就存0；而数组的最后一个元素的cur则存放第一个有数值的元素的下标，当整个链表为空时，则为0.

  　　静态链表优点：在插入和删除操作时，只需要移动游标，不需要移动元素，改进了在顺序存储结构中插入和删除操作需要移动大量元素的缺点。

   　　静态链表缺点：没有解决连续存储分配带来的表长难以确定的问题，失去了顺序存储结构随机存取的特性。

  　　静态链表的思想有点像将线性表的顺序存储和单链表结合的感觉，是为了给没有指针的高级语言设计的一种简单实现单链表功能的方法。在实际操作中，基本用不上，但是这种设计思路可以学习。

#include<stdio.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 1000 /* 存储空间初始分配量 */

typedef int Status;           /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef char ElemType;        /* ElemType类型根据实际情况而定，这里假设为char */

typedef struct
{
	ElemType data;
	int cur;
}Component,StaticLinkList[MAXSIZE];

/* 静态链表初始化：将数组中各分量链成一备用链表 */
Status InitList(StaticLinkList space)
{
	int i;
	for(i = 0 ;i < MAXSIZE - 1;i++)
		space[i].cur = i + 1;
	space[MAXSIZE - 1].cur = 0;
	return OK;
}

/* 静态链的长度 */
int ListLength(StaticLinkList space)
{
	int i,k;
	i = 0;
	k = space[MAXSIZE-1].cur;
	while(k)
	{
		k = space[k].cur;
		i++;
	}	
	return i;
}

/* 静态链的插入操作 */
int Malloc_SLL(StaticLinkList space)
{
	int i = space[0].cur;  /* 第一个备用空间的下标 */
	if (i)
	{
		space[0].cur = space[i].cur; /* 备用空间后移 */

	}
	return i;
}
Status ListInsert(StaticLinkList L,int i,ElemType e)
{
	int j,k,l;
	k = MAXSIZE - 1;
	if( i < 1 || i > ListLength(L)+1 )
		return ERROR;
	l = Malloc_SLL( L);/* 要插入位置的下标 */
	if(l)
	{
	   for(j = 1;j <= i-1;j++)
		  k = L[k].cur;   /* 找到插入的前一位置的下标 */
	      L[l].cur = L[k].cur;
		  L[l].data = e;
       	  L[k].cur = l;		  
	return OK;
	}
	return ERROR;
}

/* 静态链的删除操作 */
void Free_SLL(StaticLinkList space,int j)
{
	int i;
	i = space[0].cur;   /*删除前的备用链表的第一个下标 */ 
	space[0].cur = j;
	space[j].cur = i ;
}

Status ListDelete(StaticLinkList L,int i)
{
	int j,k;
	k = MAXSIZE - 1;
	if( i < 1 || i > ListLength(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;
	Free_SLL(L,j);
	return OK;
}

/* 静态链的查找操作 */

ElemType GetElem(StaticLinkList L,int i)
{
	int j,k;
	ElemType e;
	k = MAXSIZE - 1;
	if( i < 1 || i > ListLength(L)+1)
		return ERROR;
	for(j = 1;j <= i-1;j++)
		  k = L[k].cur;   /* 找到查找的前一位置的下标 */
	j = L[k].cur;   /* 要查找位置的下标 */
	e = L[j].data;
	return e;
}
/* 静态链的遍历操作 */
Status ListTraverse(StaticLinkList L)
{
    int j=0;
    int i=L[MAXSIZE-1].cur;
    while(i)
    {
            printf("%d  ",L[i].data);
            i=L[i].cur;
    }
	printf("\n");
    return OK;
}

int main()
{
	StaticLinkList L;
	int i,k;
	Status j;
	InitList(L);
	printf("完成静态链表的初始化，链表起始长度为：L.length = %d  \n",ListLength(L));

    printf("完成静态链表的元素表头插入:\n");
	for (i = 0;i<10;i++)
		j = ListInsert(L,1,i);
	ListTraverse(L);
	printf("\n");
  
	k = i/3;
	printf("查找静态链表的第 %d 个元素为：%d \n",k,GetElem(L,k));
	printf("\n");

	printf("删除静态链表的第 %d 个元素后：",k);
	j = ListDelete(L,k);
	ListTraverse(L);
	printf("\n");

	return 0;


}