基础数据结构及算法：链表

链表

顺序表通过连续的地址建立元素之间前后连接关系

顺序表的缺点：

1. 添加和删除操作需要移动元素
2. 当数据量特别大的情况，可能没有连续的内存可使用
   

1. 理解链表

链表通过指针方式建立元素之间前后连接关系

链表的基本用法：

#include <stdio.h>

typedef int Element;

typedef struct Node{
        Element e;
        struct Node* next;      //定义的是下一个结点指针
}Node;

int main(){
        Node n1 = {1,NULL};
        Node n2 = {2,&n1};
        Node n3 = {3,&n2};
        Node n4 = {4,&n3};

        Node* p = &n4;
        while(NULL != p){     //判断当前指针是不是空
                printf("%d ",p->e);
                p = p->next;     //指向下一个数据
        }
        printf("\n");
}

结果为：

4 3 2 1 

输出方式和字符串很像，字符串判断条件是 ‘\0’!=s[i] ，链表是 NULL!=p

2. 倒序创建链表

倒叙创建链表，打印顺序数据

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

typedef int Element;

typedef struct Node{
        Element e;
        struct Node* next;
}Node;

int main(){
        Node* header = NULL;
        for(;;){
                Element e;
                int res = scanf("%d",&e);
                if(EOF == res) break;
                Node* node = malloc(sizeof(Node));     //malloc返回申请部分的首地址
                node->e = e;
                node->next = header;    //把header存的地址给结构体指针的指针域
                header = node;        //再把这部分数据域地址给header
        }

        Node* p = header;
        while(NULL != p){
                printf("%d ",p->e);
                p = p->next;
        }
        printf("\n");
}

结果为：

3 5 4 1 2
2 1 4 5 3

3. 释放链表指针

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

typedef int Element;

typedef struct Node{
        Element e;
        struct Node* next;
}Node;

//创建链表
void Prepend(Node** header,Element e){
        Node* node = malloc(sizeof(Node));
        node->e = e;
        node->next = *header;
        *header = node;
}

//释放指针
void Destory(Node** header){
        Node* p = *header;      //把链表首数据的地址给p
        while(NULL != p){       //遍历直到最后的空指针
                Node* next = p->next;
                free(p);
                p = next;
        }
        *header = NULL;
}

int main(){
        Node* header = NULL;
        for(;;){
                Element e;
                int res = scanf("%d",&e);
                if(EOF == res) break;
                Prepend(&header,e);
        }

        Node* p = header;
        while(NULL != p){
                printf("%d ",p->e);
                p = p->next;
        }
        printf("\n");

        Destory(&header);
}

结果为：

3 5 4 1 2
2 1 4 5 3 

4. 顺序链表创建

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

typedef int Element;

typedef struct Node{
        Element e;
        struct Node* next;
}Node;

//顺序添加链表
void Append(Node** header,Element e){
        //创建结点
        Node* node = malloc(sizeof(Node));
        node->e = e;
        node->next = NULL;

        //结点连接到链表
        if(NULL == *header){         //空链接
                *header = node;      //更新头结点
        }else{
                Node* p = *header;         //p用于遍历
                while(NULL!=p->next){       //查找最后一个结点
                        p = p->next;
                }
                p->next = node;     //把新的数据地址给前一个的指针
        }
}

//释放指针
void Destory(Node** header){
        Node* p = *header;
        while(NULL != p){
                Node* next = p->next;
                free(p);
                p = next;
        }
        *header = NULL;
}

int main(){
        Node* header = NULL;
        for(;;){
                Element e;
                int res = scanf("%d",&e);
                if(EOF == res) break;
                Append(&header,e);
        }

        Node* p = header;
        while(NULL != p){
                printf("%d ",p->e);
                p = p->next;
        }
        printf("\n");

        Destory(&header);
}

结果为：

3 5 4 1 2
3 5 4 1 2 

5. 链表元素总数，查找下标对应数

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

typedef int Element;

typedef struct Node{
        Element e;
        struct Node* next;
}Node;

//链表的元素数
int GetSize(Node* header){
        int size = 0;
        Node* p = header;
        while(NULL != p){
                ++size;
                p = p->next;     //p用于从头遍历，直到链表的结尾处
        }
        return size;       //返回个数
}

//获取某一位置的数据
bool GetElement(Node* header,int index,Element* e){
        if(NULL == header) return false;              //链表没有数据，错误
        if(index < 0) return false;                   //位置数为负数，错误
        if(index >= GetSize(header)) return false;    //位置数大于总个数，错误
        Node* p = header;
        for(int i=0;i<index;++i){     //p用于从头遍历，直到输入的位置处
                p = p->next;
        }
        *e = p->e;       //给e赋值这个位置上的数
        return true;     //返回true
}


//顺序添加链表
void Append(Node** header,Element e){
        //创建结点
        Node* node = malloc(sizeof(Node));
        node->e = e;
        node->next = NULL;

        //结点连接到链表
        if(NULL == *header){
                *header = node;
        }else{
                Node* p = *header;
                while(NULL!=p->next){
                        p = p->next;
                }
                p->next = node;
        }
}

//释放指针
void Destory(Node** header){
        Node* p = *header;
        while(NULL != p){
                Node* next = p->next;
                free(p);
                p = next;
        }
        *header = NULL;
}

int main(){
        Node* header = NULL;
        for(;;){
                Element e;
                int res = scanf("%d",&e);
                if(EOF == res) break;
                Append(&header,e);
        }

        Node* p = header;
        while(NULL != p){
                printf("%d ",p->e);
                p = p->next;
        }
        printf("\n");

        printf("请输入下标：");
        int index;
        clearerr(stdin);        //清除之前EOF状态
        scanf("%d",&index);
        Element e;
        bool res=GetElement(header,index,&e);
        if(res) printf("%d\n",e);
        else printf("输入错误\n");

        Destory(&header);
}

结果为：

3 5 4 1 2
3 5 4 1 2 
请输入下标：2
4

6. 修改链表数据，规范书写

执行过程分开写，功能更清晰

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

typedef int Element;

typedef struct Node{
        Element e;
        struct Node* next;
}Node;

//链表的元素数
int GetSize(Node* header){
        int size = 0;
        Node* p = header;
        while(NULL != p){
                ++size;
                p = p->next;
        }
        return size;
}

//获取某一位置的数据
Element* GetElement(Node* header,int index){
        if(NULL == header) return NULL;
        if(index < 0) return NULL;
        if(index >= GetSize(header)) return NULL;
        Node* p = header;
        for(int i=0;i<index;++i){
                p = p->next;
        }
        return &(p->e);
}

//顺序添加链表
void Append(Node** header,Element e){
        //创建结点
        Node* node = malloc(sizeof(Node));
        node->e = e;
        node->next = NULL;

        //结点连接到链表
        if(NULL == *header){
                *header = node;
        }else{
                Node* p = *header;
                while(NULL!=p->next){
                        p = p->next;
                }
                p->next = node;
        }
}

//释放指针
void Destory(Node** header){
        Node* p = *header;
        while(NULL != p){
                Node* next = p->next;
                free(p);
                p = next;
        }
        *header = NULL;
}

//输入链表过程
Node* InputList(){
        Node* header = NULL;
        for(;;){
                Element e;
                int res = scanf("%d",&e);
                if(EOF == res) break;
                Append(&header,e);
        }
        clearerr(stdin);
        return header;
}

//输出链表过程
void DisplayList(Node* header){
        Node* p = header;
        while(NULL != p){
                printf("%d ",p->e);
                p = p->next;
        }
        printf("\n");
}

//寻找某下标数过程
void SearchList(Node* header){
        printf("请输入下标：");
        int index;
        scanf("%d",&index);
        Element* pe = GetElement(header,index);
        if(NULL != pe) printf("%d\n",*pe);
        else printf("输入错误\n");
}

//修改某下标数过程
void EditList(Node* header){
        printf("请输入下标：");
        int index;
        scanf("%d",&index);
        Element* pe = GetElement(header,index);
        if(NULL != pe){
                printf("请输入数值：");
                Element num;
                scanf("%d",&num);
                *pe = num;
        }
        else printf("输入错误\n");
}

int main(){
        Node* header = InputList();

        typedef void(*func_t)(Node* header);

        struct{
                char* name;   //选项名
                func_t func;   //执行操作
        } items[] = {
                {"查看链表",DisplayList},
                {"下标查找",SearchList},
                {"下标修改",EditList}
        };

        const int size = sizeof(items)/sizeof(items[0]);
        for(;;){
                printf("选项\n");
                for(int i=0;i<size;++i){
                        printf("%d.%s\n",i+1,items[i].name);
                }
                printf("0.退出\n");
                int item;
                printf("请输入选项：");
                scanf("%d",&item);
                if(0 == item) break;
                if(item<0||item>size){
                        printf("输入错误\n");
                        continue;
                }
                items[item-1].func(header);
        }
        Destory(&header);
}

结果为：

1 2 3 4 5
选项
1.查看链表
2.下标查找
3.下标修改
0.退出
请输入选项：2
请输入下标：3
4
选项
1.查看链表
2.下标查找
3.下标修改
0.退出
请输入选项：3
请输入下标：1
请输入数值：100
选项
1.查看链表
2.下标查找
3.下标修改
0.退出
请输入选项：1
1 100 3 4 5 
选项
1.查看链表
2.下标查找
3.下标修改
0.退出
请输入选项：0

7. 链表新成员的插入

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

typedef int Element;

typedef struct Node{
        Element e;
        struct Node* next;
}Node;

//逆顺序添加链表
void Prepend(Node** header,Element e){
        Node* node = malloc(sizeof(Node));
        node->e = e;
        node->next = *header;
        *header = node;
}

//链表的元素数
int GetSize(Node* header){
        int size = 0;
        Node* p = header;
        while(NULL != p){
                ++size;
                p = p->next;
        }
        return size;
}

//获取某一位置的数据
Element* GetElement(Node* header,int index){
        if(NULL == header) return NULL;
        if(index < 0) return NULL;
        if(index >= GetSize(header)) return NULL;
        Node* p = header;
        for(int i=0;i<index;++i){
                p = p->next;
        }
        return &(p->e);
}

//顺序添加链表
void Append(Node** header,Element e){
        //创建结点
        Node* node = malloc(sizeof(Node));
        node->e = e;
        node->next = NULL;

        //结点连接到链表
        if(NULL == *header){
                *header = node;
        }else{
                Node* p = *header;
                while(NULL!=p->next){
                        p = p->next;
                }
                p->next = node;
        }
}

//插入数据
bool Insert(Node** header,int index,Element e){
        if(index < 0) return false;
        if(index > GetSize(*header)) return false;

        //首插
        if(NULL == *header || 0 == index){
                Prepend(header,e);
                return true;
        }

        //尾插
        if(index == GetSize(*header)){
                Append(header,e);
                return true;
        }

        //中间插
        //创建结点
        Node* node = malloc(sizeof(Node));
        node->e = e;

        //查找插入位置的前一个结点
        Node* p = *header;
        for(int i=0;i<index-1;++i){
                p = p->next;
        }

        node->next = p->next;   //新结点指向后续数据地址
        p->next = node;       //前一个结点加入数据地址
}

//释放指针
void Destory(Node** header){
        Node* p = *header;
        while(NULL != p){
                Node* next = p->next;
                free(p);
                p = next;
        }
        *header = NULL;
}

//输入链表过程
Node* InputList(){
        Node* header = NULL;
        for(;;){
                Element e;
                int res = scanf("%d",&e);
                if(EOF == res) break;
                Append(&header,e);
        }
        clearerr(stdin);
        return header;
}

//输出链表过程
void DisplayList(Node** header){
        Node* p = *header;
        while(NULL != p){
                printf("%d ",p->e);
                p = p->next;
        }
        printf("\n");
}

//寻找某下标数过程
void SearchList(Node** header){
        printf("请输入下标：");
        int index;
        scanf("%d",&index);
        Element* pe = GetElement(*header,index);
        if(NULL != pe) printf("%d\n",*pe);
        else printf("输入错误\n");
}

//修改某下标数过程
void EditList(Node** header){
        printf("请输入下标：");
        int index;
        scanf("%d",&index);
        Element* pe = GetElement(*header,index);
        if(NULL != pe){
                printf("请输入数值：");
                Element num;
                scanf("%d",&num);
                *pe = num;
        }
        else printf("输入错误\n");
}

//插入数据过程
void InsertList(Node** header){
        printf("请输入下标：");
        int index;
        scanf("%d",&index);
        printf("请输入数值：");
        Element num;
        scanf("%d",&num);
        if(Insert(header,index,num)) printf("插入成功\n");
        else printf("插入失败\n");
}

int main(){
        Node* header = InputList();

        typedef void(*func_t)(Node** header);

        struct{
                char* name;   //选项名
                func_t func;   //执行操作
        } items[] = {
                {"查看链表",DisplayList},
                {"下标查找",SearchList},
                {"下标修改",EditList},
                {"插入数据",InsertList},
        };

        const int size = sizeof(items)/sizeof(items[0]);
        for(;;){
                printf("选项\n");
                for(int i=0;i<size;++i){
                        printf("%d.%s\n",i+1,items[i].name);
                }
                printf("0.退出\n");
                int item;
                printf("请输入选项：");
                scanf("%d",&item);
                if(0 == item) break;
                if(item<0||item>size){
                        printf("输入错误\n");
                        continue;
                }
                items[item-1].func(&header);
        }
        Destory(&header);
}

结果为：

1 3 5
选项
1.查看链表
2.下标查找
3.下标修改
4.插入数据
0.退出
请输入选项：4
请输入下标：1
请输入数值：2
插入成功
选项
1.查看链表
2.下标查找
3.下标修改
4.插入数据
0.退出
请输入选项：1
1 2 3 5 
选项
1.查看链表
2.下标查找
3.下标修改
4.插入数据
0.退出
请输入选项：4
请输入下标：8
请输入数值：4
插入失败
选项
1.查看链表
2.下标查找
3.下标修改
4.插入数据
0.退出
请输入选项：0

8. 链表成员的删除

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

typedef int Element;

typedef struct Node{
        Element e;
        struct Node* next;
}Node;

//逆顺序添加链表
void Prepend(Node** header,Element e){
        Node* node = malloc(sizeof(Node));
        node->e = e;
        node->next = *header;
        *header = node;
}

//链表的元素数
int GetSize(Node* header){
        int size = 0;
        Node* p = header;
        while(NULL != p){
                ++size;
                p = p->next;
        }
        return size;
}

//获取某一位置的数据
Element* GetElement(Node* header,int index){
        if(NULL == header) return NULL;
        if(index < 0) return NULL;
        if(index >= GetSize(header)) return NULL;
        Node* p = header;
        for(int i=0;i<index;++i){
                p = p->next;
        }
        return &(p->e);
}

//顺序添加链表
void Append(Node** header,Element e){
        //创建结点
        Node* node = malloc(sizeof(Node));
        node->e = e;
        node->next = NULL;

        //结点连接到链表
        if(NULL == *header){
                *header = node;
        }else{
                Node* p = *header;
                while(NULL!=p->next){
                        p = p->next;
                }
                p->next = node;
        }
}

//插入数据
bool Insert(Node** header,int index,Element e){
        if(index < 0) return false;
        if(index > GetSize(*header)) return false;

        //首插
        if(NULL == *header || 0 == index){
                Prepend(header,e);
                return true;
        }

        //尾插
        if(index == GetSize(*header)){
                Append(header,e);
                return true;
        }

        //中间插
        //创建结点
        Node* node = malloc(sizeof(Node));
        node->e = e;

        //查找插入位置的前一个结点
        Node* p = *header;
        for(int i=0;i<index-1;++i){
                p = p->next;
        }

        node->next = p->next;
        p->next = node;
}

//数据删除
bool delete(Node** header,int index){
        if(NULL == *header) return false;
        if(index < 0) return false;
        if(index >= GetSize(*header)) return false;
        //删除首数据
        Node* p = *header;
        if(0 == index){
                *header = p->next;    //头指针指向下一个数据的头
                free(p);           //释放第一个数
                return true;
        }

        //查找要删除位置的前一个结点
        for(int i=0;i<index-1;++i){
                p = p->next;
        }
/*      //删除尾数据
        if(index == getsize(*header)-1){
                free(p->next);       //释放尾数据
                p->next = NULL;      //前一个数的指针域放空
                return true;
        }
*/
        //删除中间数据
        Node* del = p->next;       //要删除数据的首地址给del
        p->next = del->next;       //删除数前数据的结点直接指向删除数的结点，也就是后一个数据的地址
        free(del);             //释放删除数据
        return true;
}

//释放指针
void Destory(Node** header){
        Node* p = *header;
        while(NULL != p){
                Node* next = p->next;
                free(p);
                p = next;
        }
        *header = NULL;
}

//输入链表过程
Node* InputList(){
        Node* header = NULL;
        for(;;){
                Element e;
                int res = scanf("%d",&e);
                if(EOF == res) break;
                Append(&header,e);
        }
        clearerr(stdin);
        return header;
}

//输出链表过程
void DisplayList(Node** header){
        Node* p = *header;
        while(NULL != p){
                printf("%d ",p->e);
                p = p->next;
        }
        printf("\n");
}

//寻找某下标数过程
void SearchList(Node** header){
        printf("请输入下标：");
        int index;
        scanf("%d",&index);
        Element* pe = GetElement(*header,index);
        if(NULL != pe) printf("%d\n",*pe);
        else printf("输入错误\n");
}

//修改某下标数过程
void EditList(Node** header){
        printf("请输入下标：");
        int index;
        scanf("%d",&index);
        Element* pe = GetElement(*header,index);
        if(NULL != pe){
                printf("请输入数值：");
                Element num;
                scanf("%d",&num);
                *pe = num;
        }
        else printf("输入错误\n");
}

//插入数据过程
void InsertList(Node** header){
        printf("请输入下标：");
        int index;
        scanf("%d",&index);
        printf("请输入数值：");
        Element num;
        scanf("%d",&num);
        if(Insert(header,index,num)) printf("插入成功\n");
        else printf("插入失败\n");
}

//删除数据过程
void DelList(Node** header){
        printf("请输入下标：");
        int index;
        scanf("%d",&index);
        bool res = delete(header,index);
        if(res){
                printf("%d删除成功\n",index);
        }
        else printf("删除失败\n");
}


int main(){
        Node* header = InputList();

        typedef void(*func_t)(Node** header);

        struct{
                char* name;   //选项名
                func_t func;   //执行操作
        } items[] = {
                {"查看链表",DisplayList},
                {"下标查找",SearchList},
                {"下标修改",EditList},
                {"插入数据",InsertList},
                {"下标删除",DelList},
        };

        const int size = sizeof(items)/sizeof(items[0]);
        for(;;){
                printf("选项\n");
                for(int i=0;i<size;++i){
                        printf("%d.%s\n",i+1,items[i].name);
                }
                printf("0.退出\n");
                int item;
                printf("请输入选项：");
                scanf("%d",&item);
                if(0 == item) break;
                if(item<0||item>size){
                        printf("输入错误\n");
                        continue;
                }
                items[item-1].func(&header);
        }
        Destory(&header);
}

结果为：

1 2 3 4 5
选项
1.查看链表
2.下标查找
3.下标修改
4.插入数据
5.下标删除
0.退出
请输入选项：5
请输入下标：3
3删除成功
选项
1.查看链表
2.下标查找
3.下标修改
4.插入数据
5.下标删除
0.退出
请输入选项：1
1 2 3 5 
选项
1.查看链表
2.下标查找
3.下标修改
4.插入数据
5.下标删除
0.退出
请输入选项：0

9. 优化

1. header指针和链表长度size经常用，可以用一个结构体专门定义，和顺序表相似
2. 封装文件，把程序分为 list.c、list.h、main.c 三个文件

list.c 文件内容：

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include "list8.h"

//创建初始化
List* Create(){
        List* list = malloc(sizeof(List));
        list->header = NULL;
        list->size = 0;
        return list;
}

//销毁指针
void Destory(List** list){
        Node* p = (*list)->header;
        while(NULL != p){
                Node* next = p->next;
                free(p);
                p = next;
        }

        free(*list);
        *list = NULL;
}

//逆顺序添加链表
void Prepend(List* list,Element e){
        Node* node = malloc(sizeof(Node));
        node->e = e;
        node->next = list->header;
        list->header = node;
        list->size++;           //增加元素计数
}

//链表的元素数
int GetSize(List* list){
        return list->size;      //直接返回元素个数
}

//获取某一位置的数据
Element* GetElement(List* list,int index){
        if(NULL == list->header) return NULL;
        if(index < 0) return NULL;
        if(index >= GetSize(list)) return NULL;
        Node* p = list->header;
        for(int i=0;i<index;++i){
                p = p->next;
        }
        return &(p->e);
}

//顺序添加链表
void Append(List* list,Element e){
        //创建结点
        Node* node = malloc(sizeof(Node));
        node->e = e;
        node->next = NULL;

        //结点连接到链表
        if(NULL == list->header){
                list->header = node;
        }else{
                Node* p = list->header;
                while(NULL!=p->next){
                        p = p->next;
                }
                p->next = node;
        }
        list->size++;        //添加元素计数
}

//插入数据
bool Insert(List* list,int index,Element e){
        if(index < 0) return false;
        if(index > GetSize(list)) return false;

        //首插
        if(NULL == list->header || 0 == index){
                Prepend(list,e);
                return true;
        }

        //尾插
        if(index == GetSize(list)){
                Append(list,e);
                return true;
        }

        //中间插
        //创建结点
        Node* node = malloc(sizeof(Node));
        node->e = e;

        //查找插入位置的前一个结点
        Node* p = list->header;
        for(int i=0;i<index-1;++i){
                p = p->next;
        }

        node->next = p->next;
        p->next = node; 

        list->size;            //增加数据计数 
}

//数据删除
bool delete(List* list,int index){
        if(NULL == list->header) return false;
        if(index < 0) return false;
        if(index >= GetSize(list)) return false;
        //删除首数据
        Node* p = list->header;
        if(0 == index){
                list->header = p->next;
                free(p);
                return true;
        }

        //查找要删除位置的前一个结点
        for(int i=0;i<index-1;++i){
                p = p->next;
        }
        //删除中间和尾数据
        Node* del = p->next;
        p->next = del->next;
        free(del);
        list->size--;           //数据个数减少计数        
        return true;
}

list.h 文件内容：

#pragma once

#include <stdbool.h>

typedef int Element;

typedef struct Node{
        Element e;
        struct Node* next;
}Node;

//再建结构体用于封装
typedef struct List{
        Node* header;
        int size;
}List;

List* Create();
void Destory(List** list);
void Prepend(List* list,Element e);
int GetSize(List* list);
Element* GetElement(List* list,int index);
void Append(List* list,Element e);
bool Insert(List* list,int index,Element e);
bool delete(List* list,int index);

main.c 文件内容：

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include "list8.h"

//输入链表过程
List* InputList(){
        List* list = Create();
        for(;;){
                Element e;
                int res = scanf("%d",&e);
                if(EOF == res) break;
                Append(list,e);
        }
        clearerr(stdin);
        return list;
}

//输出链表过程
void DisplayList(List* list){
        Node* p = list->header;
        while(NULL != p){
                printf("%d ",p->e);
                p = p->next;
        }
        printf("\n");
}

//寻找某下标数过程
void SearchList(List* list){
        printf("请输入下标：");
        int index;
        scanf("%d",&index);
        Element* pe = GetElement(list,index);
        if(NULL != pe) printf("%d\n",*pe);
        else printf("输入错误\n");
}

//修改某下标数过程
void EditList(List* list){
        printf("请输入下标：");
        int index;
        scanf("%d",&index);
        Element* pe = GetElement(list,index);
        if(NULL != pe){
                printf("请输入数值：");
                Element num;
                scanf("%d",&num);
                *pe = num;
        }
        else printf("输入错误\n");
}

//插入数据过程
void InsertList(List* list){
        printf("请输入下标：");
        int index;
        scanf("%d",&index);
        printf("请输入数值：");
        Element num;
        scanf("%d",&num);
        if(Insert(list,index,num)) printf("插入成功\n");
        else printf("插入失败\n");
}

//删除数据过程
void DelList(List* list){
        printf("请输入下标：");
        int index;
        scanf("%d",&index);
        bool res = delete(list,index);
        if(res){
                printf("%d删除成功\n",index);
        }
        else printf("删除失败\n");
}


int main(){
        List* list = InputList();

        typedef void(*func_t)(List* list);

        struct{
                char* name;
                func_t func;
        } items[] = {
                {"查看链表",DisplayList},
                {"下标查找",SearchList},
                {"下标修改",EditList},
                {"插入数据",InsertList},
                {"下标删除",DelList},
        };

        const int size = sizeof(items)/sizeof(items[0]);
        for(;;){
                printf("选项\n");
                for(int i=0;i<size;++i){
                        printf("%d.%s\n",i+1,items[i].name);
                }
                printf("0.退出\n");
                int item;
                printf("请输入选项：");
                scanf("%d",&item);
                if(0 == item) break;
                if(item<0||item>size){
                        printf("输入错误\n");
                        continue;
                }
                items[item-1].func(list);
        }
        Destory(&list);
}

结果为：

1 2 3 4 5
选项
1.查看链表
2.下标查找
3.下标修改
4.插入数据
5.下标删除
0.退出
请输入选项：2
请输入下标：2
3
选项
1.查看链表
2.下标查找
3.下标修改
4.插入数据
5.下标删除
0.退出
请输入选项：3
请输入下标：4
请输入数值：8
选项
1.查看链表
2.下标查找
3.下标修改
4.插入数据
5.下标删除
0.退出
请输入选项：1
1 2 3 4 8 
选项
1.查看链表
2.下标查找
3.下标修改
4.插入数据
5.下标删除
0.退出
请输入选项：4
请输入下标：0
请输入数值：100
插入成功
选项
1.查看链表
2.下标查找
3.下标修改
4.插入数据
5.下标删除
0.退出
请输入选项：1
100 1 2 3 4 8 
选项
1.查看链表
2.下标查找
3.下标修改
4.插入数据
5.下标删除
0.退出
请输入选项：5
请输入下标：1
1删除成功
选项
1.查看链表
2.下标查找
3.下标修改
4.插入数据
5.下标删除
0.退出
请输入选项：1
100 2 3 4 8 
选项
1.查看链表
2.下标查找
3.下标修改
4.插入数据
5.下标删除
0.退出
请输入选项：0