数据结构——C语言实现静态链表

#include
#define MaxSize 100
#define ElemType int

//定义结构体
typedef struct{
    ElemType data;
    int cur;//游标，当cur=0时则无指向
}Componet,StaticLinkList[MaxSize];
//index = 0的空间中存放备用链表的游标，数组的最后一个隔子里存放第一个元素的下标(类似头节点)

//初始化
void InitList(StaticLinkList L){
    if(L!=NULL){
        for(int i = 1; i < MaxSize - 1; i++){
            L[i].data = -1;
            L[i].cur = i + 1;
        }

        //最后一个空格(类似头节点)指向链表的第一个元素，0:表示链表为空
        L[MaxSize - 1].data = 0;//链表长度
        L[MaxSize - 1].cur = 0;

        //第一个空格中存放备用链表的索引,指向第一个空闲的空格
        L[0].cur = 1;
    }
}
//判断线性表是否为空
int ListEmpty(StaticLinkList L){
    if(L==NULL){
        return 1;
    }
    //当头节点的下一个节点是index= 0，则说明为空或者头节点中存放的链表长度为0
    if(L[MaxSize - 1].data == 0 || L[MaxSize - 1].cur == 0 ){
        return 1;
    }
    return 0;
}

int ListLength(StaticLinkList L){
    //满足链表长度为0
    if(L==NULL || L[MaxSize - 1].data == 0 || L[MaxSize - 1].cur == 0){
        return 0;
    }
    return L[MaxSize - 1].data;
}

int ListFull(StaticLinkList L){
    if(L!=NULL){
        if(ListLength(L) == MaxSize - 2){
            return 1;
        }
    }
    return 0;
}

void OutPutList(StaticLinkList L){
    int j = L[MaxSize - 1].cur;
    for(int i = 1; i <= ListLength(L); i++){
        printf("%d\n",L[j].data);
        j = L[j].cur;
    }
}

//申请一个新的节点
int MallocNode(StaticLinkList L){
    if(L == NULL || ListFull(L)){
        return 0;
    }
    int i = L[0].cur;//第一个空闲空间
    L[0].cur = L[i].cur;//第一个空闲空间被占用了，更新第一个空闲空间
    return i;
}

int ListInsert(StaticLinkList L,int i,ElemType e){
    if(i < 1 || i > ListLength(L) + 1 || ListFull(L) == 1){
        printf("the index you insert is error.\n");
        return 0;
    }
    
    //申请一个新的节点
    int index = MallocNode(L);
    if(index == 0){
        return 0;
    }
    L[index].data = e;
    //找到第i-1 , i个节点
    int k = MaxSize - 1;//最后一个元素的索引
    int j = 0;
    while(j < i - 1){//找到第i-1个节点的
        k = L[k].cur;//k移至下一个节点
        j++;
    }
    int kNext = L[k].cur;//第i个节点的下标
    
    L[k].cur = index;//第i-1节点的cur指向e
    L[index].cur = kNext;//新的节点的下标指向第i节点的index
    L[MaxSize - 1].data++;//链表长度+1
    return 1;
}

//清空线性表
void ClearList(StaticLinkList L){
    if(L!=NULL){
        for(int i = 0; i < MaxSize; i++){
            L[i].data = -2;
            L[i].cur = -1;
        }
    }
}
//获取L中第i个元素的值并返回
int GetElem(StaticLinkList L,int i,ElemType *e){
    if(i < 1 || i > ListLength(L) + 1){
        return 0;
    }
    int j = L[MaxSize - 1].cur;
    int k = 1;
    while(k < i){
        j = L[j].cur;
        k++;
    }
    *e = L[j].data;
    return j;
}

//查找e的位置(第几个节点)，失败则返回0
int LocateElem(StaticLinkList L,ElemType e){
    if(L!=NULL && ListEmpty(L) != 1){
        int count = 1;
        int i = L[MaxSize - 1].cur;
        while(count <= ListLength(L)){
            if(L[i].data == e){
                return count;
            }
            i = L[i].cur;
            count ++;
        }
    }
    return 0;
}

//删除L中第i个元素，并用e返回
int ListDelete(StaticLinkList L, int i, ElemType *e){
    if(i < 1 || i > ListLength(L)){
        return 0;
    }
    int k = MaxSize - 1;
    int count = 0;
    //找到第i - 1个元素
    while(count < i - 1){
        k = L[k].cur;
        count ++;
    }
    int index = L[k].cur;//第i个元素的索引
    *e = L[index].data;//第i个元素

    L[k].cur = L[index].cur;//将第i-1个元素指向i+1个元素的索引

    L[MaxSize - 1].data --;//链表长度-1

    //更新空闲空格的索引
    L[index].cur = L[0].cur;
    L[0].cur = index;
    return 1;

}

int main(){
    StaticLinkList L;
    ElemType e = -1;
    int i = 8;
    InitList(L);//初始化
    for(int i = 1; i <= 10; i++){
        ListInsert(L,i,1000+i);
    }
    ListDelete(L,1,&e);
    printf("the deleted elment is %d\n",e);
    ListInsert(L,7,1000);
    GetElem(L,i,&e);
    printf("第%d个节点 = %d\n",i,e);
    printf("length = %d\n",ListLength(L));
    printf("listempty = %d\n",ListEmpty(L));
    printf("listfull = %d\n",ListFull(L));
    printf("the %d element is the %d one\n",1004,LocateElem(L,1004));
    OutPutList(L);
    ClearList(L);
    OutPutList(L);

    return 0;
}