静态链表的实现

原文链接

静态链表

在没有指针或对象引用机制的编程语言中，链表结构也可以用数组来描述，这种用数组描述的链表就叫“静态链表”，也叫“游标实现法”。
结构说明如下图（图是盗的，莫怪）：

结构和基本操作

接下来就用C语言来描述静态链表的结构和基本操作：

头文件 StaticLinkList.h

#ifndef STATICLINKLIST_H  
#define STATICLINKLIST_H  

/*定义状态码*/  
#define ERROR -1  
#define TRUE 1  
#define FALSE 0  
typedef int Status;  

/*定义结构体*/  
#define MAXSIZE 5  
typedef int ElemType;  
typedef struct  
{  
    ElemType data;  
    int cur;  
}Node , StaticLinkList[MAXSIZE];  

/*函数原型说明*/  
void InitList(StaticLinkList list);  
int GetListLength(StaticLinkList list);  
int Malloc_SSL(StaticLinkList list);  
void Free_SLL(StaticLinkList list , int i);  
Status InsertList(StaticLinkList list , int i , ElemType e);  
Status DeleteList(StaticLinkList list , int i);  
void Print(StaticLinkList list);  

#endif  

静态链表基本操作的实现：

#include "StaticLinkList.h"  
#include<stdio.h>  

/*初始化静态数组*/  
void InitList(StaticLinkList list)  
{  
    int i;  
    for(i=0 ; i < MAXSIZE - 1 ; i++)  
    {  
        list[i].cur=i+1;  
    }  
    list[MAXSIZE-1].cur=0;  
}  

/*返回静态链表中数据元素的个数*/  
int GetListLength (StaticLinkList list)  
{  
    int count = 0;  
    int cur = list[MAXSIZE - 1].cur;  

    while(cur)  
    {  
        cur = list[cur].cur;  
        count++;  
    }  

    return count;  
}  

/*返回备用数组下标，无备用空间则返回0*/  
int Malloc_SLL(StaticLinkList list)  
{  
    int i = list[0].cur;  
    if (i)  
    {  
        if ((GetListLength(list) + 1) >= MAXSIZE - 2)   
        {  
            list[0].cur = 0;  
        }  
        else  
        {  
            list[0].cur = list[i].cur;  
        }  
    }  
    return i;  
}  

/*将下标为 i 的节点回收到备用链表*/  
void Free_SLL (StaticLinkList list , int i)  
{  
    list[i].cur = list[0].cur;  
    list[0].cur = i;  
}  

/*静态链表的插入操作*/  
Status InsertList (StaticLinkList list , int i , ElemType e)  
{  
    int j , k;  

    if (i < 1 || i > GetListLength(list)+1)   
    {  
        return ERROR;  
    }  

    j = Malloc_SLL(list);  
    k = MAXSIZE - 1;  
    if (j)  
    {  
        int l;  
        for(l = 0 ; l < i - 1 ; l++)  
        {  
            k = list[k].cur;  
        }  
        list[j].data = e;  
        list[j].cur = list[k].cur;  
        list[k].cur = j;  
        return TRUE;  
    }  
    return FALSE;  
}  

/*静态链表的删除操作*/  
Status DeleteList(StaticLinkList list , int i)  
{  
    int j , k , l;  

    if(i < 1 || i > GetListLength(list))  
    {  
        return ERROR;  
    }  

    k = MAXSIZE - 1;  
    for(l = 0 ; l < i - 1 ; l++)  
    {  
        k = list[k].cur;  
    }  
    j = list[k].cur;  
    list[k].cur = list[j].cur;  
    Free_SLL(list , j);  
        return TRUE;  
    }  

    void Print(StaticLinkList list)  
    {  
        int k = MAXSIZE - 1;  
        int j = 0;  
        while(list[k].cur)  
        {  
        j = list[k].cur;  
        printf("%d\n" , list[j].data);  
        k = j;  
    }  
}  

main函数，简单测试：

#include "StaticLinkList.h"  
#include<stdio.h>  
int main ()   
{  
    int status;  
    StaticLinkList list;  
    InitList(list);  
    status = InsertList(list , 1 , 1);  
    status = InsertList(list , 2 , 2);  
    status = InsertList(list , 3 , 3);  
    status = DeleteList(list , 2);  
    Print(list);  
}  

结束 :)