静态链表

来源：互联网发布：服装设计的网络课程编辑：程序博客网时间：2024/04/30 01:21
静态数组实际有2个链表，一个链表上链接的是线性表的结点，另一个链表把所有空闲结点链接形成一个备用链表，数组下标为0的单元为备用链表的头结点。cur值为0的结点为线性表的尾结点。
代码：
[cpp] view plaincopy
#include <string.h>     
#include <ctype.h>     
#include <malloc.h>  // malloc()等     
#include <limits.h>  // INT_MAX等     
#include <stdio.h>   // EOF(=^Z或F6),NULL     
#include <stdlib.h>  // atoi()     
#include <io.h>      // eof()     
#include <math.h>    // floor(),ceil(),abs()     
#include <process.h> // exit()     
  
// 函数结果状态代码     
#define TRUE  1     
#define FALSE 0     
#define OK    1     
#define ERROR 0     
#define INFEASIBLE -1     
// #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行     
typedef int Status;  // Status是函数的类型,其值是函数结果状态代码，如OK等     
typedef int Boolean; // Boolean是布尔类型,其值是TRUE或FALSE   
  
typedef int ElemType;  
  
// 线性表的静态单链表存储结构  
#define MAX_SIZE 100 // 链表的最大长度  
typedef struct  
{  
    ElemType data;  
    int cur;  
}component, SLinkList[MAX_SIZE];  
  
int Malloc(SLinkList space)   
{ // 若备用链表非空，则返回分配的结点下标(备用链表的第一个结点)，否则返回0  
    int i = space[0].cur;  
    if (i)  
        space[0].cur = space[i].cur;  
    return i;  
}  
  
void Free(SLinkList space, int k)   
{ // 将下标为空的空闲结点回收到备用链表(成为备用链表的第一个结点)  
    space[k].cur = space[0].cur;  
    space[0].cur = k;  
}  
  
// 一个数组只生成一个静态链表的基本操作(11个))  
#define DestroyList ClearList // DestroyList()和ClearList()的操作是一样的  
void InitList(SLinkList L)  
{ // 构造一个空的链表L，表头为L的最后一个单元L[MAX_SIZE-1]，其余单元链成  
    // 一个备用链表，表头为L的第一个单元L[0]，“0”表示空指针  
    int i;  
    L[MAX_SIZE - 1].cur = 0;  
    for (i = 0; i < MAX_SIZE - 2; i++)  
        L[i].cur = i + 1;  
    L[MAX_SIZE - 2].cur = 0;      
}  
  
void ClearList(SLinkList L)  
{ // 初始条件：线性表L已存在。操作结果：将L重置为空表  
    int i, j, k;  
    i = L[MAX_SIZE - 1].cur;  
    L[MAX_SIZE - 1].cur = 0;  
    k = L[0].cur;  
    L[0].cur = i;  
    while (i)  
    {  
        j = i;  
        i = L[i].cur;  
    }  
    L[j].cur = k;  
}  
  
Status ListEmpty(SLinkList L)  
{ // 若L是空表，返回TRUE；否则返回FALSE  
    if (!L[MAX_SIZE - 1].cur)  
        return TRUE;  
    else  
        return FALSE;  
}  
  
int ListLength(SLinkList L)  
{ // 返回L中数据元素个数  
    int i, length;  
    i = L[MAX_SIZE - 1].cur;  
    length = 0;  
    while (i)  
    {  
        i = L[i].cur;  
        length++;  
    }  
    return length;  
}  
  
Status GetElem(SLinkList L, int i, ElemType &e)  
{ // 用e返回L中第i个元素的值  
    int j, k = MAX_SIZE - 1;  
    if (i < 1 || i > ListLength(L))  
        return ERROR;  
    for (j = 1; j <= i; j++)  
        k = L[k].cur;  
    e = L[k].data;  
    return OK;  
}  
  
int LocateElem(SLinkList L, ElemType e)   
{ // 在静态单链线性表L中查找第1个值为e的元素。若找到，则返回它在L中的  
    // 位序，否则返回0。(与其它LocateElem()的定义不同)  
    int i = L[MAX_SIZE - 1].cur;  
    while (i && L[i].data != e)  
        i = L[i].cur;  
    return i;  
}  
  
Status PriorElem(SLinkList L, ElemType cur_e, ElemType &pre_e)  
{ // 初始条件：线性表L已存在  
    // 操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，  
    //           否则操作失败，pre_e无定义  
    int i, j;  
    i = L[MAX_SIZE - 1].cur;      
    do   
    {  
        j = i;  
        i = L[i].cur;  
    } while (i && L[i].data != cur_e);  
    if (i)  
    {  
        pre_e = L[j].data;  
        return OK;  
    }  
    return ERROR;  
}  
  
Status NextElem(SLinkList L, ElemType cur_e, ElemType &next_e)  
{ // 初始条件：线性表L已存在  
    // 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，  
    //           否则操作失败，next_e无定义  
    int i, j;  
    i = LocateElem(L, cur_e);  
    if (i)  
    {  
        j = L[i].cur;  
        if (j)  
        {  
            next_e = L[j].data;  
            return OK;  
        }  
    }  
    return ERROR;  
}  
  
Status ListInsert(SLinkList L, int i, ElemType e)  
{ // 在L中第i个元素之前插入新的数据元素e  
    int j, k, l;  
    k = MAX_SIZE - 1;  
    if (i < 1 || i > ListLength(L) + 1)  
        return ERROR;  
    j = Malloc(L);  
    if (j)  
    {  
        L[j].data = e;  
        for(l = 1; l <= i - 1; l++)  
            k = L[k].cur;  
        L[j].cur = L[k].cur;  
        L[k].cur = j;  
        return OK;  
    }  
    return ERROR;  
}  
  
Status ListDelete(SLinkList L, int i, ElemType &e)  
{ // 删除在L中第i个数据元素e，并返回其值  
    int j, k;  
    if (i < 1 || i > ListLength(L))  
        return ERROR;  
    k = MAX_SIZE - 1;  
    for (j = 1; j <= i - 1; j++)  
        k = L[k].cur;  
    j = L[k].cur;  
    L[k].cur = L[j].cur;  
    e = L[j].data;  
    Free(L, j);  
    return OK;  
}  
  
void ListTraverse(SLinkList L, void(*vi)(ElemType))  
{ // 初始条件：线性表L已存在。操作结果：依次对L的每个数据元素调用函数vi()  
    int i = L[MAX_SIZE - 1].cur;  
    while (i)  
    {  
        vi(L[i].data);  
        i = L[i].cur;  
    }  
}  
  
void print(ElemType c)  
{  
    printf("%d ",c);  
}  
  
void main()  
{  
    int j, k;  
    Status i;  
    ElemType e, e0;  
    SLinkList L;  
    InitList(L);  
    for(j = 1; j <= 5; j++)  
        i = ListInsert(L, 1, j);  
    printf("在L的表头依次插入1～5后：L=");  
    ListTraverse(L, print);  
    i = ListEmpty(L);  
    printf("/nL是否空:i=%d(1:是 0:否)表L的长度=%d/n",i, ListLength(L));  
    ClearList(L);  
    printf("清空L后：L=/n");  
    ListTraverse(L, print);  
    i = ListEmpty(L);  
    printf("L是否空:i=%d(1:是 0:否)表L的长度=%d/n",i, ListLength(L));  
    for(j = 1; j <= 10; j++)  
        ListInsert(L, j, j);  
    printf("在L的表尾依次插入1～10后：L=");  
    ListTraverse(L, print);  
    GetElem(L, 5, e);  
    printf("/n第5个元素的值为：%d/n", e);  
    for(j = 0; j <= 1; j++)  
    {  
        k = LocateElem(L, j);  
        if(k)  
            printf("值为%d的元素在静态链表中的位序为%d/n", j, k);  
        else  
            printf("没有值为%d的元素/n", j);  
    }  
    for(j = 1; j <= 2; j++) // 测试头两个数据  
    {  
        GetElem(L, j, e0); // 把第j个数据赋给e0  
        i=PriorElem(L, e0, e); // 求e0的前驱  
        if(!i)  
            printf("元素%d无前驱/n", e0);  
        else  
            printf("元素%d的前驱为：%d/n", e0, e);  
    }  
    for(j = ListLength(L) - 1; j <= ListLength(L); j++) // 最后两个数据  
    {  
        GetElem(L, j, e0); // 把第j个数据赋给e0  
        i=NextElem(L, e0, e); // 求e0的后继  
        if(!i)  
            printf("元素%d无后继/n", e0);  
        else  
            printf("元素%d的后继为：%d/n", e0, e);  
    }  
    k = ListLength(L); // k为表长  
    for(j = k + 1; j >= k; j--)  
    {  
        i=ListDelete(L, j, e); // 删除第j个数据  
        if(i)  
            printf("第%d个元素为%d,已删除。/n", j, e);  
        else  
            printf("删除第%d个元素失败(不存在此元素)。/n", j);  
    }  
    printf("依次输出L的元素：");  
    ListTraverse(L, print); // 依次对元素调用print()，输出元素的值  
}  