数据结构-线性表-静态链表完整可执行代码

数据结构-线性表-静态链表完整可执行代码（c语言描述）

 

/***************************************************************************

 *

 * 静态链表

 * ADT (List)

 * Data

 *   {a1, a2, a3, ..., an}

 * Operation

 *   InitList(*L);               初始化静态链表L.

 *   ListEmpty(L);               静态链表L,返回true,否则返回false.

 *   ClearList(*L);              将单链表L清空.

 *   GetElem(L, i, *e);          将单链表L中第i个位置元素值返回给e.

 *   LocateElem(L, e);           在L查找和e相等的元素,成功返回元素所在的.

 *                               序号,否则,返回0表示失败.

 *   ListInsert(*L, i, e);       在L中第i个位置插入新元素e.

 *   ListDelete(*L, i);          删除L中第i个位置的元素.

 *   ListLength(L);              返回线性表L的元素个数.

 * ENDADT

 *

 * 逻辑结构

 *                    0|a0| m|  ----> 备用链表头指针

 *                    1|a1| 2|

 *                    2|a2| 3|

 *                      .. ..

 *                    i|ai| 0|

 *                      .. ..

 *                max-1|an| 1|  ----> 链表头指针

 *

 * 修改记录：

 *           2012-12-11 重新组织代码,编译调试，修正语法错误.

 */





/************************ data   静态链表存储结构定义 *********************/



#define MAXSIZE 1000            /* 假设链表最大的长度为1000 */

#define OK      1

#define ERROR   0

#define TRUE    1

#define FALSE   0



typedef int ElemType;           /* ElemType 类型根据实际情况而定,现假设为 int */

typedef int Status;             /* Status 是函数的类型，其值是函数结果状态代码 */



/* 静态链表存储结构 */

typedef struct{

    ElemType data;

    int cur;                      /* 游标(cursor) 为0 时表示无指向 */

}Component, StaticLinkList[MAXSIZE];



/***************************** operation 操作 *****************************/



/*

 * 初始条件：静态链表L不存在。

 * 操作结果：将一维数组space中各个分量链成一备用链表

 * 数组第一个元素的游标cur用来存放备用链表第一个节点的下标。

 * 数组最后一个元素的游标cur存放第一个有数值元素的下标，相当

 * 于单链表的头节点。

 */

Status InitList(StaticLinkList space)

{

    int i;

    for(i = 0; i < MAXSIZE - 1; i++){

        space[i].cur = i + 1;

    }

    

    space[MAXSIZE - 1].cur = 0;   /* 目前静态链表为空，最后一个元素的cur 为0 */

    

    return OK;

}



/*

 * 初始条件：静态链表L已存在

 * 操作结果：如果静态链表为空，返回true，否则返回false

 */

Status ListEmpty(StaticLinkList L)

{

    return (ListLength(L) == 0 ? TRUE : FALSE);

}



/* 若备用空间链表非空，则返回分配的节点下标，否则返回0 */

int Malloc_SLL(StaticLinkList space)

{

    int i = space[0].cur;         /* 当前数组第一元素的cur存的值，

                                   就是要返回第一个备用空闲的下标. */

    

    /* 由于要拿出一个分量来使用了，所以需要

     把它的下一个分量用来做准备 */

    if(space[0].cur)

        space[0].cur = space[i].cur;

    

    return i;

}



/*

 * 初始条件: 静态链表L已存在

 * 操作结果：将静态链表L元素清空为0，长度置为0

 *           备用链表置为初始状态

 */

void ClearList(StaticLinkList L)

{

    int i;

    i = L[MAXSIZE - 1].cur;

    

    while(i){

        L[i].data = 0;

        ListDelete(L,i);

    }

}



/*

 * 初始条件：静态链表L已存在，1 <= i <= ListLength(L)

 * 操作结果：用e返回L中第i个元素的值

 */

Status GetElem(StaticLinkList L, int i, ElemType *e)

{

    int j;

    int k;

    j = L[MAXSIZE - 1].cur;

    k = 1;

    

    while(j && k < i){

        j = L[j].cur;

        k++;

    }

    if(!j || k > i)

        return ERROR;

    

    *e = L[j].data;

    return OK;

}



/*

 * 初始条件：静态链表L已存在.

 * 操作结果：在L查找和e相等的元素，成功返回元素所在的序号，

 *           否则，返回0表示失败

 */

Status LocateElem(StaticLinkList L, ElemType e)

{

    int i = L[MAXSIZE - 1].cur;

    

    while(i){

        if (L[i].data == e)

            return i;

        i = L[i].cur;

    }

    

    return 0;

}



/*

 * 初始条件: 静态链表L已存在，1 <= i <= ListLength(L)

 * 操作结果：在L中第i个位置之前插入新元素e , L的长度加1

 */

Status ListInsert(StaticLinkList L, int i, ElemType e)

{

    int j;

    int k;

    int l;

    

    k = MAXSIZE - 1;                  /* 注意k首先是最后一个元素的下标,即头指针 */

    

    if(i < 1 || i > ListLength(L) + 1)

        return ERROR;

    

    j = Malloc_SLL(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元素之前元素的cur */

        

        return OK;

    }

    

    return ERROR;

}



/* 将下标为k的空闲节点回收到备用链表,类似头插入法 */

void Free_SLL(StaticLinkList space, int k)

{

    space[k].cur = space[0].cur;      /* 把第一个元素cur值赋给要删除的分量的cur */

    space[0].cur = k;                 /* 把要删除的元素的下标赋给头指针cur */

}



/*

 * 初始条件: 静态链表L已存在，1 <= i <= ListLength(L)

 * 操作结果：删除在L中第i个元素e.

 */

Status ListDelete(StaticLinkList L, int i)

{

    int j;

    int k;

    

    if (i < 1 || i > ListLength(L))

        return ERROR;

    

    k = MAXSIZE - 1;

    for(j = 1; j <= i - 1; j++){      /* 找到要删除的元素的前一个位置的下标 */

        k = L[j].cur;

    }

    j = L[k].cur;                     /* 暂存要删除的元素的下标 */

    L[k].cur = L[j].cur;              /* 把要删除的元素的前一个元素的游标改要

                                       删除元素的后继 */

    

    Free_SLL(L, j);

    return OK;

}



/*

 * 初始条件：静态链表L已经存在.

 * 操作结果：返回L的元素个数.

 */

int ListLength(StaticLinkList L)

{

    int j = 0;

    int i = L[MAXSIZE - 1].cur;

    

    while(i){

        i = L[i].cur;

        j++;

    }

    

    return j;

}



int main()

{

//    具体操作...

//    StaticLinkList L;

//    InitList(L);

    return 0;

}