数据结构之线性表4单链表（静态单链表）

静态链表（Static Linked List）是利用一组地址连续的内存空间来描述线性链表，把数组元素作为存储结点，数组元素类型包含数值域data和游标指示器cur。游标定义为整型，指示结点在数组中的相对位置。通常下标为零的元素被看成是头结点，其游标指示器指示线性链表的第一个结点。这种存储结构同样具有链式存储结构的主要优点，即在插入和删除元素时只需要修改游标而不用移动元素，但也有一些缺点，例如要预先分配一个较大的空间。

大概结构图如下

                                    

在静态链表中，每一个结点包含两部分内容，一部分是data（即有意义的数据），另一部分是cur（存储该元素下一个元素所在数组对应的下标）。

有几个特殊的结点：

首先是下标为0的结点中不包含有意义的数据，它的cur存储的是备用链表（即没有存储的数据的那些结点）第一个结点的下标。如上图2所示，数组第一个元素的cur存放的是7。

其次是数组最后一个元素，数组最后一个元素的cur存放的是静态链表的第一个结点的下标（此处的第一个结点，是指有实质意义的数据的结点）。

最后就是链表的最后一个元素（并不一定是数组的最后一个元素），链表最后一个元素的cur一般存放0，表示它后面的结点为空了。

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

#define MAX_SIZE 100 /* 链表的最大长度 */

typedef struct

{

 ElemType data;//此處的ElemType可以自由代換（如int/float等）

  intcur;

}component,SLinkList[MAX_SIZE];

/*一个数组只生成一个静态链表的基本操作(11个))*/

#define DestroyList ClearList //DestroyList()和ClearList()的操作是一样的

void InitList(SLinkList L)

{ /* 构造一个空的链表L，表头为L的最后一个单元L[MAX_SIZE-1]，其余单元链成 */

  /* 一个备用链表，表头为L的第一个单元L[0]，“0”表示空指针 */

  inti;

 L[MAX_SIZE-1].cur=0; /* L的最后一个单元为空链表的表头 */

 for(i=0;i<MAX_SIZE-2;i++) /* 将其余单元链接成以L[0]为表头的备用链表 */

   L[i].cur=i+1;

 L[MAX_SIZE-2].cur=0;

}

void ClearList(SLinkList L)

{ /* 初始条件：线性表L已存在。操作结果：将L重置为空表 */

  inti,j,k;

 i=L[MAX_SIZE-1].cur; /* 链表第一个结点的位置 */

 L[MAX_SIZE-1].cur=0; /* 链表空 */

 k=L[0].cur; /* 备用链表第一个结点的位置 */

 L[0].cur=i; /* 把链表的结点连到备用链表的表头 */

 while(i) /* 没到链表尾 */

  {

   j=i;

   i=L[i].cur; /* 指向下一个元素 */

  }

 L[j].cur=k; /* 备用链表的第一个结点接到链表的尾部 */

}

Status ListEmpty(SLinkList L)

{ /* 若L是空表，返回TRUE；否则返回FALSE */

 if(L[MAX_SIZE-1].cur==0) /* 空表 */

   return TRUE;

 else

   return FALSE;

}

int ListLength(SLinkList L)

{ /* 返回L中数据元素个数 */

  intj=0,i=L[MAX_SIZE-1].cur; /* i指向第一个元素 */

 while(i) /* 没到静态链表尾 */

  {

   i=L[i].cur; /* 指向下一个元素 */

   j++;

  }

 return j;

}

Status GetElem(SLinkList L,int i,ElemType*e)

{ /* 用e返回L中第i个元素的值 */

  intl,k=MAX_SIZE-1; /* k指向表头序号 */

 if(i<1||i>ListLength(L))

   return ERROR;

 for(l=1;l<=i;l++) /* 移动到第i个元素处 */

   k=L[k].cur;

 *e=L[k].data;

 return OK;

}

int LocateElem(SLinkList L,ElemType e) /* 算法2.13(有改动) */

{ /* 在静态单链线性表L中查找第1个值为e的元素。若找到，则返回它在L中的 */

  /* 位序，否则返回0。(与其它LocateElem()的定义不同) */

  inti=L[MAX_SIZE-1].cur; /* i指示表中第一个结点 */

 while(i&&L[i].data!=e) /* 在表中顺链查找(e不能是字符串) */

   i=L[i].cur;

 return i;

}

Status PriorElem(SLinkList L,ElemTypecur_e,ElemType *pre_e)

{ /* 初始条件：线性表L已存在 */

  /* 操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱， */

 /*           否则操作失败，pre_e无定义 */

  intj,i=L[MAX_SIZE-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 OK;

  }

 return ERROR;

}

Status NextElem(SLinkList L,ElemTypecur_e,ElemType *next_e)

{ /* 初始条件：线性表L已存在 */

  /* 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继， */

 /*           否则操作失败，next_e无定义 */

  intj,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 OK; /* cur_e元素有后继 */

    }

  }

 return ERROR; /* L不存在cur_e元素，cur_e元素无后继 */

}

Status ListInsert(SLinkList L,inti,ElemType e)

{ /* 在L中第i个元素之前插入新的数据元素e*/

  intl,j,k=MAX_SIZE-1; /* k指向表头 */

 if(i<1||i>ListLength(L)+1)

   return ERROR;

 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 OK;

  }

 return ERROR;

}

Status ListDelete(SLinkList L,inti,ElemType *e)

{ /* 删除在L中第i个数据元素e，并返回其值 */

  intj,k=MAX_SIZE-1; /* k指向表头 */

 if(i<1||i>ListLength(L))

   return ERROR;

 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 OK;

}

void ListTraverse(SLinkListL,void(*vi)(ElemType))

{ /* 初始条件：线性表L已存在。操作结果：依次对L的每个数据元素调用函数vi()*/

  inti=L[MAX_SIZE-1].cur; /* 指向第一个元素 */

 while(i) /* 没到静态链表尾 */

  {

   vi(L[i].data); /* 调用vi() */

   i=L[i].cur; /* 指向下一个元素 */

  }

 printf("\n");

}