数据结构 - 静态单链表的实行（C语言）

静态单链表的实现

1 静态链表定义

静态链表存储结构的定义如下：

/* 线性表的静态链表存储结构 */
#define MAXSIZE 1000 /* 假设链表的最大长度是1000 */
typedef struct
{
  ElemType data;
  int cur; /* 游标(Cursor)，为0时表示无指向 */
}Component, StaticLinkList[MAXSIZE];    

另外我们对数组第一个和最后一个元素作为特殊元素处理，不存数据。我们通常把未被使用的数组元素称为备用链表。而数组第一个元素，即下标为0的元素的cur就存放备用链表的第一个结点的下标；而数组的最后一个元素的cur则存放第一个有数值的元素的下标，相当于单链表中的头结点作用，当整个链表为空时，则为0。有些书中把教组的第二个元素用来作为头结点，实现原理相同。只不过是取得存放位置。不同如下图所示。

假设我们已经将数据存入静态链表，比如分别存放着“甲"、"乙"、"丁" 等数据，则它将如下图所示。

2 静态链表的初始化

静态链表初始化的代码如下：

/* 将一维数组space中各分量链成一个备用链表，space[0].cur为头指针，"0"表示空指针 */
Status InitList(StaticLinkList space)
{
    int i;
    for (i = 0; i

3 静态链表插入

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

/* 若备用空间链表非空，则返回分配的结点下标，否则返回0 */
int Malloc_SSL(StaticLinkList space)
{
    int i = space[0].cur;                   /* 当前数组第一个元素的cur存的值 */
    /* 就是要返回的第一个备用空闲的下标 */
    if (space[0].cur)
        space[0].cur = space[i].cur;       /* 由于要拿出一个分量来使用了， */
    /* 所以我们就得把它的下一个 */
    /* 分量用来做备用 */
    return i;
}

上面代码一方面的作用就是返回一个下标值，这个值就是数组头元素的cur存的第一个空闲的下标。从上面的图示例子来看，其实就是返回7。
那么既然下标为7的分量准备要使用了，就得有接替者，所以就把分量7的cur值赋值给头元素，也就是把8给space[0].cur，之后就可以继续分配新的空闲分量，
实现类似malloc()函数的作用。

假设我们需要在乙丁之间插入一个值为丙的元素，事实上只要做4步操作，并如下图所示：

1. 将丙放到备用链表第一个位置
2. 修改丙的cur为乙的cur游标
3. 修改乙的cur游标为丙所在的索引
4. 修改下标为0的cur的位置为新的备用链表第一个结点的下标

实现代码如下：

/*  在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 TRUE;   
    }   
    return FALSE;   
}

4 静态链表的删除操作

和前面一样，删除元素时，原来是需要释放结点的函数free()。现在我们也得自己实现它：

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

假设我们需要要删除值为丙的元素，事实上只要做3步操作，并如下图所示：

1、将下标为999（也就是最后一个元素）的cur修改为要删除的元素的下标

2、将要删除的元素的cur为下标为0的cur（也就是说现在要删除的元素才是备用链表的第一个结点，原先备用链表的第一个结点成为将要删除元素的后继结点了）

3、将要删除的分量下标赋值给第一个元素的cur

/*  删除在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;   
} 

5 完整实现

#include "stdafx.h"

#define TRUE 1
#define FALSE 0

#define MAXSIZE 1000 /* 存储空间初始分配量 */

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


Status visit(ElemType c)
{
    printf("%c ", c);
    return TRUE;
}

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


/* 将一维数组space中各分量链成一个备用链表，space[0].cur为头指针，"0"表示空指针 */
Status InitList(StaticLinkList space)
{
    int i;
    for (i = 0; i ListLength(L) + 1)
        return FALSE;
    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 TRUE;
    }
    return FALSE;
}

/*  删除在L中第i个数据元素   */
Status ListDelete(StaticLinkList L, int i)
{
    int j, k;
    if (i < 1 || i > ListLength(L))
        return FALSE;
    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 TRUE;
}

Status ListTraverse(StaticLinkList L)
{
    int j = 0;
    int i = L[MAXSIZE - 1].cur;
    while (i)
    {
        visit(L[i].data);
        i = L[i].cur;
        j++;
    }
    return j;
    printf("\n");
    return TRUE;
}


int main()
{
    StaticLinkList L;
    Status i;
    i = InitList(L);
    printf("初始化L后：L.length=%d\n", ListLength(L));

    i = ListInsert(L, 1, 'F');
    i = ListInsert(L, 1, 'E');
    i = ListInsert(L, 1, 'D');
    i = ListInsert(L, 1, 'B');
    i = ListInsert(L, 1, 'A');

    printf("\n在L的表头依次插入FEDBA后：\nL.data=");
    ListTraverse(L);

    i = ListInsert(L, 3, 'C');
    printf("\n在L的“B”与“D”之间插入“C”后：\nL.data=");
    ListTraverse(L);

    i = ListDelete(L, 1);
    printf("\n在L的删除“A”后：\nL.data=");
    ListTraverse(L);

    printf("\n");

    return 0;
}

/*
输出结果：

初始化L后：L.length=0

在L的表头依次插入FEDBA后：
L.data=A B D E F
在L的“B”与“D”之间插入“C”后：
L.data=A B C D E F
在L的删除“A”后：
L.data=B C D E F
*/

转载于:https://www.cnblogs.com/linuxAndMcu/p/10308819.html