【数据结构】链式型存储结构-静态链表

1  前言

地球人都知道C语言是个伟大的语言，它的魅力在于指针的灵活性，使得它可以非常容易地操作内存中的地址和数据，这比其他高级语言更加灵活方便。（面向对象语言，比如java，可以使用对象引用机制间接地实现指针的某些功能）

但是古人还是木有C语言丫，木有JAVA丫，只有原始的Basic，Fortran 等早期的编程语言，这些语言没有类似于C的指针功能，但是他们又想描述单链表，就没法实现了，肿么办？

2  静态链表

因此计算机的先辈们就想出来用数组代替指针来描述单链表。而这种用数组描述的链表叫做静态链表，这种描述方法叫做游标实现法。

• 下标为0，数据不存放任何东西，下标为 MAXSIZE-1 时，即999，不存放数据

• 最后一个元素，也就是下标为999，游标 1 指向数组当中第一个数据不为空的元素的下标 1即数据A

• 下标 0 所对应的游标 5 指向数组当中没有存放数据的第一个元素，即下标为5的元素

• 其他元素的游标都是直接指向它的下一个元素的下标

线性表的静态链表存储结构：

#define MAXSIZE 1000
typedef struct
{
    ElemType data; //数据
    int cur; //游标（Cursor）
} Component, StaticLinkList[MAXSIZE];

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

Status InitList(StaticLinkList space)
{
    int i;
    for( i=0; i < MAXSIZE-1; i++){
        space[i].cur = i + 1; //第i个元素的游标指向i+1
    }
    
    space[MAXSIZE-1].cur = 0; //最后一个元素的游标指向0，因为此时为空表
    
    return 0;
}

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

• 我们通常把未使用的数组元素称为备用链表。

• 数组的第一个元素，即下标为0的那个元素的cur就存放备用链表的第一个结点的下标（也就是没有存放数据的元素下标）。

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

3  静态链表的操作

3.1  静态链表的插入

静态链表中要解决的是：如何用静态模拟动态链表的存储空间分配，也就是需要的时候申请，不需要的时候释放。

在动态链表中，结点的申请和释放分别借用C语言的malloc() 和 free() 两个函数来实现。

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

为了辨明数组中哪些分量未被使用，解决的办法是将所有未被使用过的及已被删除的用游标链成一个备用链表。

每当进行插入的时候，便可以从备用链表上取得第一个结点作为待插入的新结点。下面以在A后边插入B为例进行说明。

首先是获得空闲分量的下标： 

int Malloc_SLL(StaticLinkList space)
{
    int i = space[0].cur; // i = 5
    if( space[0].cur )
    {
        space[0].cur = space[i].cur; //sapce[0].cur=space[5].cur=6;
    }
    return i;
}

插入操作的实现代码：

Status ListInsert( StaticLinkList L, int i, ElemType e ){
    int j, k, l;
    
    k = MAXSZIE - 1; //数组的最后一个元素的下标，k = 999
    if ( i<1 || i > ListLength(L) + 1)
    {
        return ERROR;
    }
    
    j = Malloc_SLL(L); //获得备用链表第一个元素的下标，j = 5;
    if( j )
    {
        L[j].data = e; //L[5].data = B
        //i=2,也就是往第二个元素之前插入B
        for( l=1; l <= i-1; l++)
        {
            //L[k].cur=L[MAXSZIE-1].cur，表示第一个有数值的元素的下标
            k = L[k].cur; // k = 1;
        }
        //将插入元素的前一个元素的游标赋值给插入元素的游标
        L[j].cur = L[k].cur; //L[5].cur = L[1].cur = 2; B的游标变为2
        //将当前插入元素的下标赋值给它的前一个元素的游标
        L[k].cur = j; //L[1].cur = 5; A的游标变为5
    }
    
}

3.2  静态链表的删除

我们以删除C之后的游标变化图示：

Status ListDelte(StaticLinkList L, int i)  //i=3,元素为C
{
    int j, k;
    
    if( i<1 || i>ListLength(L))
    {
        return EROOR;
    }
    
    k = MAXSZIE-1;
    for( j=1; j <= i-1; j++){
        k = L[k].cur; //k1 = 1,k2 = 5
    }
    
    j = L[k].cur; //j = L[5].cur = 2;
    L[k].cur = L[j].cur; //B的游标变为了3
    
    Free_SLL(L, j);
    
    return OK;
}

void Free_SLL(StaticLinkList space, int k)
{
    space[k].cur = space[0].cur; //把备用链表的第一个元素的下标给了下标k的游标
    space[0].cur = k; //静态链表的第一个元素的游标指向k
}

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

3.3  静态链表优缺点小结

优点：

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

缺点：

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

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

总的来说，静态链表其实是为了给没有指针的编程语言设计的一种实现单链表功能的方法。尽管我们可以用单链表就不用静态链表了，但这样的思考方式是非常巧妙的，应该理解其思想，以备不时之需。

4  引申

如何快速找到未知长度单链表的中间结点。

普通方法很简单，首先遍历一遍单链表以确定单链表的长度L。然后再次从头结点出发循环L/2次找到单链表的中间结点。算法的复杂度为：O(L+L/2)=O(3L/2)

利用快慢指针原理：设置两个指针*search、*mid 都是指向单链表的头结点。其中 *search 的移动速度是 *mid的2倍。当*search 指向末尾结点的时候，*mid 正好就在中间了。

Status GetMidNode(LinkList L, ElemType *e)
{
    LinkList search, mid;
    mid = search = L;
    while(search->next != NULL)
    {
        if(search->next->next != NULL)
        {
            search = search->next->next;
        }
        else
        {
            search = search->next;
        }
        mid = mid->next;
    }
    
    *e = mid->data;
    
    return Ok;
}

5  小结

好了，静态链表我们就看到这里哈，有理解不对的地方欢迎指正哈。