数据结构--静态链表

// STATICLINKLIST.H

/***************************************************************************
 * File: STATICLINKLIST.h
 * Author: suzhaoda ([email protected])
 *
 * 静态链表
 * ADT (List)
 * Data
 *   {a1, a2, a3, ..., an}
 * Operation
 *   InitList(*L);               初始化静态链表L.
 *   ListEmpty(L);               静态链表L,返回true,否则返回false.
 *   ClearList(*L);              将单链表L清空.
 *   GetElem(L, i, *e);          将单链表L中第i个位置元素值返回给e.
 *   LocateElem(L, e);           在L查找和e相等的元素,成功返回元素所在的.
 *                               序号,否则,返回0表示失败.
 *   ListInsert(*L, i, e);       在L中第i个位置插入新元素e.
 *   ListDelete(*L, i);          删除L中第i个位置的元素.
 *   ListLength(L);              返回线性表L的元素个数.
 * ENDADT
 *
 * 逻辑结构
 *                    0|a0| m|  ----> 备用链表头指针
 *                    1|a1| 2|
 *                    2|a2| 3|
 *                      .. ..
 *                    i|ai| 0|
 *                      .. ..
 *                max-1|an| 1|  ----> 链表头指针
 *
 * 修改记录：
 *           2012-12-11 重新组织代码,编译调试，修正语法错误.
 */

#ifndef STATICLINKLIST_H_INCLUDED
#define STATICLINKLIST_H_INCLUDED

/************************ data   静态链表存储结构定义 *********************/

#define MAXSIZE 1000            /* 假设链表最大的长度为1000 */
#define OK      1
#define ERROR   0
#define TRUE    1
#define FALSE   0

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

/* 静态链表存储结构 */
typedef struct{
  ElemType data;
  int cur;                      /* 游标(cursor) 为0 时表示无指向 */
}Component, StaticLinkList[MAXSIZE];

/***************************** operation 操作 *****************************/

/*
 * 初始条件：静态链表L不存在。
 * 操作结果：将一维数组space中各个分量链成一备用链表
 * 数组第一个元素的游标cur用来存放备用链表第一个节点的下标。
 * 数组最后一个元素的游标cur存放第一个有数值元素的下标，相当
 * 于单链表的头节点。
 */
Status InitList(StaticLinkList space);

/*
 * 初始条件：静态链表L已存在
 * 操作结果：如果静态链表为空，返回true，否则返回false
 */
Status ListEmpty(StaticLinkList L);

/* 若备用空间链表非空，则返回分配的节点下标，否则返回0 */
int Malloc_SLL(StaticLinkList space);

/*
 * 初始条件: 静态链表L已存在
 * 操作结果：将静态链表L元素清空为0，长度置为0
 *           备用链表置为初始状态
 */
void ClearList(StaticLinkList L);

/*
 * 初始条件：静态链表L已存在，1 <= i <= ListLength(L)
 * 操作结果：用e返回L中第i个元素的值
 */
Status GetElem(StaticLinkList L, int i, ElemType *e);

/*
 * 初始条件：静态链表L已存在.
 * 操作结果：在L查找和e相等的元素，成功返回元素所在的序号，
 *           否则，返回0表示失败
 */
Status LocateElem(StaticLinkList L, ElemType e);

/*
 * 初始条件: 静态链表L已存在，1 <= i <= ListLength(L)
 * 操作结果：在L中第i个位置之前插入新元素e , L的长度加1
 */
Status ListInsert(StaticLinkList L, int i, ElemType e);

/* 将下标为k的空闲节点回收到备用链表,类似头插入法 */
void Free_SLL(StaticLinkList space, int k);

/*
 * 初始条件: 静态链表L已存在，1 <= i <= ListLength(L)
 * 操作结果：删除在L中第i个元素e.
 */
Status ListDelete(StaticLinkList L, int i);

/*
 * 初始条件：静态链表L已经存在.
 * 操作结果：返回L的元素个数.
 */
int ListLength(StaticLinkList L);

#endif // STATICLINKLIST_H_INCLUDED
//----------------------------------------------------------------------------------------------
//STATICLINKLIST.C


#include "STATICLINKLIST.h"

Status InitList(StaticLinkList space)
{
  int i;
  for(i = 0; i < MAXSIZE - 1; i++){
    space[i].cur = i + 1;
  }

  space[MAXSIZE - 1].cur = 0;   /* 目前静态链表为空，最后一个元素的cur 为0 */

  return OK;
}

Status ListEmpty(StaticLinkList L)
{
  return (ListLength(L) == 0 ? TRUE : FALSE);
}

int Malloc_SLL(StaticLinkList space)
{
  int i = space[0].cur;         /* 当前数组第一元素的cur存的值，
                                   就是要返回第一个备用空闲的下标. */

  /* 由于要拿出一个分量来使用了，所以需要
     把它的下一个分量用来做准备 */
  if(space[0].cur)
    space[0].cur = space[i].cur;

  return i;
}

void ClearList(StaticLinkList L)
{
  int i;
  i = L[MAXSIZE - 1].cur;

  while(i){
    L[i].data = 0;
    ListDelete(L,i);
  }
}

Status GetElem(StaticLinkList L, int i, ElemType *e)
{
  int j;
  int k;
  j = L[MAXSIZE - 1].cur;
  k = 1;

  while(j && k < i){
    j = L[j].cur;
    k++;
  }
  if(!j || k > i)
    return ERROR;

  *e = L[j].data;
  return OK;
}

Status LocateElem(StaticLinkList L, ElemType e)
{
  int i = L[MAXSIZE - 1].cur;

  while(i){
    if (L[i].data == e)
      return i;
    i = L[i].cur;
  }

  return 0;
}

Status ListInsert(StaticLinkList L, int i, ElemType e)
{
  int j;
  int k;
  int l;

  k = MAXSIZE - 1;                  /* 注意k首先是最后一个元素的下标,即头指针 */

  if(i < 1 || i > ListLength(L) + 1)
    return ERROR;

  j = Malloc_SLL(L);                /* 获取空闲分量的下标 */

  if(j){
    L[j].data = e;                  /* 将数据赋给此分量的data */
    for(l = 1; l <= i - 1; l++)     /* 从表头开始找到第i元素之前的位置 */
      k = L[k].cur;

    L[j].cur = L[k].cur;            /* 把第i元素之前的cur赋值给新元素的cur */
    L[k].cur = j;                   /* 把新元素的下标赋值给第i元素之前元素的cur */

    return OK;
  }

  return ERROR;
}

void Free_SLL(StaticLinkList space, int k)
{
  space[k].cur = space[0].cur;      /* 把第一个元素cur值赋给要删除的分量的cur */
  space[0].cur = k;                 /* 把要删除的元素的下标赋给头指针cur */
}

 Status ListDelete(StaticLinkList L, int i)
{
  int j;
  int k;

  if (i < 1 || i > ListLength(L))
    return ERROR;

  k = MAXSIZE - 1;
  for(j = 1; j <= i - 1; j++){      /* 找到要删除的元素的前一个位置的下标 */
    k = L[j].cur;
  }
  j = L[k].cur;                     /* 暂存要删除的元素的下标 */
  L[k].cur = L[j].cur;              /* 把要删除的元素的前一个元素的游标改要
                                       删除元素的后继 */

  Free_SLL(L, j);
  return OK;
}

int ListLength(StaticLinkList L)
{
  int j = 0;
  int i = L[MAXSIZE - 1].cur;

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

  return j;
}

参考：《大话数据额结构》