单向静态链表

单项静态链表的实现

辅助空间本身就是一个链表，只是他链接的都是尚未使用的元素，通过实现的Malloc_SL来返回未使用的元素，这时辅助空间链表把该元素从链表中删除，然后返回该元素。Free_SL后则把该元素重新回收到辅助空间。可以看到，其他链表和辅助空间是共享同一片连续内存空间的，但是它们各不相干扰。

一些必要声明

#include <stdio.h>
#include <stdlib.h>

#define MAXSIZE 1000

typedef int Status;
typedef int ElemType;


typedef struct
{
    ElemType data;
    int cur;
}component,SLinkList[MAXSIZE];

找到e的位置

静态链表为空时直接返回

静态链表非空时且和e不等时一直找，直到结尾或找到

/**
 * 找到静态链表中第一个为e的元素的位置,若找到则返回位置i,否则返回0
 */
int LocateElem_SL(SLinkList Space, int S, ElemType e)
{
    int i = Space[S].cur;   /* i指示表中第一个结点 */
    while(i && Space[i].data != e)
        i = Space[i].cur;
    return i;
}

初始化辅助链表空间

/**
 * 将一维数组space中各个分量链接成一个链表，space[0].cur为头指针
 * 初始化时因为没有空间被使用过，所以头指针指向的第一个结点刚好1
 */
void InitSpace_SL(SLinkList space)
{
    for(int i=0; i<MAXSIZE-1;i++)
        space[i].cur = i+1;
    space[MAXSIZE-1].cur = 0; /* 令最后一个指向0，空指针*/
}

malloc的实现

/**
 * 从备用空间中获取可以空间的索引，若备用空间非空，则返回结点下标，否则返回0
 */
int Malloc_SL(SLinkList space)
{   
    int i = space[0].cur;
    if(space[0].cur) /* 若备用空间非空，结点头指针指向下下一个结点 */
        space[0].cur = space[i].cur;
    return i;
}

free 的实现

/**
 * 将下标为看的空闲空间结点回收到备用链表
 */
void Free_SL(SLinkList space,int k)
{
    if(k<1 || k>MAXSIZE-1) 
        return ;
    space[k].cur = space[0].cur;
    space[0].cur = k;
}

创建静态链表

/**
 * 创建静态链表
 */
void CreatList_SL(SLinkList Space, int *S, int n)
{
    *S = Malloc_SL(Space);  /* 创建头结点 */
    Space[*S].cur = 0;
    Space[*S].data = 0;
    int t;
    for( ; n>0; n--) {
        t = Malloc_SL(Space);
        scanf("%d",&Space[t].data);
        Space[t].cur = Space[*S].cur; /* 先让新创建的结点指向同一个 */
        Space[*S].cur = t;            /* *S 指向新创建的结点 */
    }
}

插入到第i个位置，即第i-1的后面

/**
 * 插入到第i个位置，即第i-1的后面
 */
int SListInsert(SLinkList Space, int S, int i, ElemType e)
{
    int r = S; /* 指向头结点 */
    int k=0;   
    while(r && k<i-1) {
        r = Space[r].cur;
        k++;
    }
    /* 退出循环后r应该指向i-1，若i-1位置为空，则说明插入的位置不对 */
    if(!r || k>i-1)
        return ERROR;
    int t = Malloc_SL(Space);
    Space[t].data = e;
    Space[t].cur = Space[r].cur;  /* 插入点指向i */
    Space[r].cur = t;             /* i-1指向插入点 */
    return OK;
}

删除静态链表中的第i个元素

/**
 * 删除静态链表中的第i个元素
 */
int ListDelete_SL(SLinkList Space, int S, int i,ElemType *e)
{
    int p,q; 
    p = S;   /* 指向头结点 */
    int k=0; /* k从0开始 */
    while (Space[p].cur && k<i-1) {
        p = Space[p].cur;
        k++;
    }
    /* 循环退出后p应该指向i-1结点，Space[p].cur 指向i结点
     * 若Space[p].cur 为空，则要删除的i结点不存在 */
    if(!(Space[p].cur) || k>i-1)
        return ERROR;
    q = Space[p].cur;               /* q指向待删除的第i个结点 */
    Space[p].cur = Space[q].cur;    /* 原p直接跳过原i指向原i+1 */
    *e = Space[q].data;
    Free_SL(Space,q);
    return OK;
}

打印静态链表

void printList(SLinkList Space, int S)
{
    int k = Space[S].cur; /* 指向第一个结点 */
    while (k) {           /* 若当前结点不为空 */
        printf("%d ",Space[k].data);
        k = Space[k].cur; /* 指向下一个结点 */
    }
    printf("
");
}

测试主函数

int main()
{
    SLinkList Space;
    InitSpace_SL(Space);
    int S;
    CreatList_SL(Space,&S,5);
    ElemType e;
    SListInsert(Space, S, 1,250);
    SListInsert(Space, S, 1,350);
    ListDelete_SL(Space, S, 5,&e);
    printList(Space,S);

    int location_e_5 = LocateElem_SL(Space,S,5);
    printf("%d",Space[location_e_5].data);
}