静态链表

在有些语言当中是没有指针的，比如说Basic、Fortan等早期的编程高级语言，由于没有指针，链表结构如果像我们实现单链表的形式来实现肯定是实现不了了，所以我们就想出了用数组来代替指针

我们让数组的元素都是由两个数据域组成，data和cur，也就是说数组的每一个下标都对应一个data和一个cur，数据域data，用来存放数据元素，cur则是相当于单链表当中的next指针，这种用数组描述的指针就叫做静态链表

我们对数组的第一个和最后一个元素作为特殊元素处理，不存数据，我们通常把未被使用的数组元素称为备用链表。数组当中的第一个元素，即下标为0的元素的cur存放的就是备用链表的第一个结点的下标，而数组的最后一个元素的cur则存放的是第一个有数值数组的元素的下标，相当于是单链表当中的头结点的作用

下面是静态链表的存储结构

#define MAXSIZE 1000 /* 存储空间初始分配量 */
typedef char ElemType; /* ElemType类型这里定义为int*/
/* 线性表的静态链表存储结构 */
typedef struct 
{
    ElemType data;
    int cur;  /* 游标(Cursor) ，为0时表示无指向 */
} 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; /* 目前静态链表为空，最后一个元素的cur为0 */
    return OK;
}

返回备用链表当中的结点下标

/* 若备用空间链表非空，则返回分配的结点下标，否则返回0 */
int Malloc_SSL(StaticLinkList space) 
{ 
        //第一个元素的cur就是备用链表当中第一个结点的下标
    int i = space[0].cur;                   /* 当前数组第一个元素的cur存的值 */
                                            /* 就是要返回的第一个备用空闲的下标 */

    if (space[0]. cur)         
        //备用链表的第一个结点的cur的值赋值给我要设置第一个元素的cur的值，因为原本的第一个已经被使用了
        space[0]. cur = space[i].cur;       /* 由于要拿出一个分量来使用了， */
                                            /* 所以我们就得把它的下一个 */
                                            /* 分量用来做备用 */
    return i;
}

静态链表的插入操作

/*  在L中第i个元素之前插入新的数据元素e   */
Status ListInsert(StaticLinkList L, int i, ElemType e)   
{  
    int j, k, l;   
    k = MAXSIZE - 1;   /* 注意k首先是最后一个元素的下标 */
    if (i < 1 || i > ListLength(L) + 1)   
        return ERROR;   
    j = Malloc_SSL(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个元素之前元素的ur */
        return OK;   
    }   
    return ERROR;   
}

静态链表当中的删除操作

/*  删除在L中第i个数据元素   */
Status ListDelete(StaticLinkList L, int i)   
{ 
    int j, k;   
    if (i < 1 || i > ListLength(L))   
        return ERROR;   
    k = MAXSIZE - 1;   
    for (j = 1; j <= i - 1; j++)   
        k = L[k].cur;   
    j = L[k].cur;   
    L[k].cur = L[j].cur;   
    Free_SSL(L, j);   
    return OK;   
} 

再来看下关于Free_SSL的实现

/*  将下标为k的空闲结点回收到备用链表 */
void Free_SSL(StaticLinkList space, int k) 
{  
    space[k].cur = space[0].cur;    /* 把第一个元素的cur值赋给要删除的分量cur */
    space[0].cur = k;               /* 把要删除的分量下标赋值给第一个元素的cur */
}

获取静态链表的长度

/* 初始条件：静态链表L已存在。操作结果：返回L中数据元素个数 */
int ListLength(StaticLinkList L)
{
    int j=0;
    int i=L[MAXSIZE-1].cur;
    //因为如果i为0就说明到底了
    while(i)
    {
        i=L[i].cur;
        j++;
    }
    return j;
}

静态链表的优缺点如下所示