目录

一、链表的概念

1.1 什么是链表：

二、链表和数组的区别：

2.1 链表和数组的优缺点：

        2.1.1 数组的优缺点：

        2.1.2 链表的优缺点：

三、链表的静态添加和动态遍历：

四、统计链表节点个数及链表查找

五、链表插入

5.1 链表从指定节点后方插入新节点：

5.2 链表从指定节点前方插入新节点：

六、链表删除指定节点

七、改变链表指定节点的数据

八、动态创建链表

8.1 动态创建链表之头插法：

8.2 动态创建链表之尾插法：

九、链表增删改查

一、链表的概念

1.1 什么是链表：

• 链表是一种数据结构，是一种数据存放的思想.

二、链表和数组的区别：

• 数组静态分配内存，链表动态分配内存

• 数组在内存中是连续的，链表是不连续的

• 数组利用下标定位，链表通过遍历定位元素

• 数组插入和删除需要移动其他元素，链表的插入或删除不需要移动其他元素

2.1 链表和数组的优缺点：

2.1.1 数组的优缺点：

• 随机访问性比较强，可以通过下标进行快速定位。

• 查找速度快

• 插入和删除的效率低，需要移动其他元素。

• 会造成内存的浪费，因为内存是连续的，所以在申请数组的时候就必须规定内存的大小，如果不合适，就会造成内存的浪费。

• 内存空间要求高，创建一个数组，必须要有足够的连续内存空间。

• 数组的大小是固定的，在创建数组的时候就已经规定好，不能动态拓展。

2.1.2 链表的优缺点：

• 插入和删除的效率高，只需要改变指针的指向就可以进行插入和删除。

• 内存利用率高，不会浪费内存，可以使用内存中细小的不连续的空间，只有在需要的时候才去创建空间。大小不固定，拓展很灵活。

• 查找的效率低，因为链表是从第一个节点向后遍历查找。

#include struct Test
{int data;			//存放的数据struct Test *nest;	//下一个节点的地址
};int main()
{int i;int len;int arr[3] = {1,2,3};len = sizeof(arr)/sizeof(arr[0]);for(i=0; idata,t1.nest->nest->data);return 0;
}
/*
CLC@Embed_Learn:~/lianbiao$ gcc link.c -o link
CLC@Embed_Learn:~/lianbiao$ ./link
1 2 3 
use t1 to print three nums
1 2 3
*/

三、链表的静态添加和动态遍历：

#include struct Test
{int data;			//数据struct Test *nest;	//指向同类型的指针
};//链表动态遍历输出
void printLink(struct Test *hand)
{struct Test *point;	point = hand;						//point指向链表头while(point != NULL){				//遍历到链表尾巴NULL时，循环结束printf("%d ",point->data);	//输出当前节点data的值point = point->nest;		//point指向下一个节点}putchar('\n');
};int main()
{//对所有的节点进行赋值struct Test t1 = {1,NULL};	struct Test t2 = {2,NULL};struct Test t3 = {3,NULL};struct Test t4 = {4,NULL};t1.nest = &t2;	//将节点t2的地址赋值给t1节点的nestt2.nest = &t3;	//将节点t3的地址赋值给t2节点的nestt3.nest = &t4;	//将节点t4的地址赋值给t3节点的nestprintf("use t1 to ptint four nums\n");printLink(&t1);	//把链表头传到printLink函数中去return 0;
}
/*
CLC@Embed_Learn:~/lianbiao$ gcc link1.c -o link1
CLC@Embed_Learn:~/lianbiao$ ./link1
use t1 to ptint four nums
1 2 3 4 */

四、统计链表节点个数及链表查找

#include struct Test
{int data;			//数据struct Test *nest;	//指向同类型的指针
};//链表动态遍历输出
void printLink(struct Test *hand)
{struct Test *point;point = hand;					//point指向链表头		while(point != NULL){			//遍历到链表尾巴NULL时，循环结束printf("%d ",point->data);	//输出当前节点data的值point = point->nest;		//point指向下一个节点}putchar('\n');
}//统计链表节点个数函数
int getLinkTotalNodeNum(struct Test *hand)
{int cnt = 0;struct Test *point;point = hand;					//point指向链表头	while(point != NULL){			//遍历到链表尾巴NULL时，循环结束cnt++;point = point->nest;		//point指向下一个节点}return cnt;
}//查找链表函数
int searchLink(struct Test *hand, int data)
{struct Test *point;point = hand;					//point指向链表头	while(point != NULL){			//遍历到链表尾巴NULL时，循环结束if(point->data == data){	//如果当前节点的数据和输入的数据一样return 1;				//找到就返回1}point = point->nest;		//point指向下一个节点}return 0;						//没有找到就返回0
}int main()
{struct Test t1 = {1,NULL};struct Test t2 = {2,NULL};struct Test t3 = {3,NULL};struct Test t4 = {4,NULL};struct Test t5 = {5,NULL};t1.nest = &t2;		//将节点t2的地址赋值给t1节点的nestt2.nest = &t3;		//将节点t3的地址赋值给t2节点的nestt3.nest = &t4;		//将节点t4的地址赋值给t3节点的nestt4.nest = &t5;		//将节点t5的地址赋值给t4节点的nestprintf("链表动态输出：\n");printLink(&t1);		//把链表头传到printLink函数中去int ret = getLinkTotalNodeNum(&t1);printf("链表的节点个数是：%d\n",ret);ret = searchLink(&t1,1);	//函数返回最终结果if(ret == 0){printf("没有找到1\n");}else{printf("找到1了\n");}ret = searchLink(&t1,8);	//函数返回最终结果if(ret == 0){printf("没有找到8\n");}else{printf("找到8了\n");}return 0;
}
/*
E:\code\一阶段C语言\链表>gcc demo_lb_bianli.cE:\code\一阶段C语言\链表>a.exe
链表动态输出：
1 2 3 4 5
链表的节点个数是：5
找到1了
没有找到8
*/

五、链表插入

• 关于链表的插入有两种方式：

• 第一种：从指定节点后方插入新节点

• 第二种：从指定指点前方插入新节点

5.1 链表从指定节点后方插入新节点：

#include struct Test
{int data;			//数据struct Test *nest;	//指向同类型的指针
};//链表动态遍历输出
void printLink(struct Test *hand)
{struct Test *point;point = hand;					//point指向链表头		while(point != NULL){			//遍历到链表尾巴NULL时，循环结束printf("%d ",point->data);	//输出当前节点data的值point = point->nest;		//point指向下一个节点}putchar('\n');
}//从指定节点后方插入新节点
int insertFromBehind(struct Test *hand, int data, struct Test *new)
{struct Test *p = hand;while(p != NULL){if(p->data == data){	//判断当前节点是不是指定节点new->nest = p->nest;//把新节点的next指向指定节点的下一个节点(这边要注意顺序不能换，否则链表会断掉)p->nest = new;		//再把指定节点的next指向新节点return 1;}p = p->nest;			//p指向下一节点}return 0;
}int main()
{struct Test *hand = NULL;//定义结构体变量，作为节点，给节点赋值struct Test t1 = {1,NULL};struct Test t2 = {2,NULL};struct Test t3 = {3,NULL};struct Test t4 = {4,NULL};struct Test t5 = {5,NULL};t1.nest = &t2;		//将节点t2的地址赋值给t1节点的nestt2.nest = &t3;		//将节点t3的地址赋值给t2节点的nestt3.nest = &t4;		//将节点t4的地址赋值给t3节点的nestt4.nest = &t5;		//将节点t5的地址赋值给t4节点的nesthand = &t1;struct Test new = {100,NULL};	//定义一个新节点printf("链表动态输出：\n");printLink(hand);		//把链表头传到printLink函数中去int ret = insertFromBehind(hand, 3, &new);	//把链表头,要插入的位置,和新节点的地址传递过去if(ret == 1){printf("插入成功！\n");}else{printf("插入失败！\n");}printLink(hand);	//把链表头传过去,打印链表return 0;
}
/*
E:\code\一阶段C语言\链表>gcc demo_指定节点后方插入新节点.cE:\code\一阶段C语言\链表>a.exe
链表动态遍历：
1 2 3 4 5
插入成功！
1 2 3 100 4 5
*/

5.2 链表从指定节点前方插入新节点：

如果要在指定节点前插入新节点的话，需要考虑两种情况：

1. 在第一个节点前插入新节点

2. 在中间指定节点前插入新节点

#include struct Test
{int data;			//数据struct Test *nest;	//指向同类型的指针
};//链表动态遍历输出
void printLink(struct Test *hand)
{struct Test *p = hand;		//p指向链表头while(p != NULL){			//遍历到链表尾巴NULL时，循环结束printf("%d ",p->data);	//输出当前节点data的值p = p->nest;			//p指向下一个节点}putchar('\n');
}//链表在指定节点前方插入新节点
struct Test* insertFromfront(struct Test *hand, int data, struct Test *new)
{struct Test *p = hand;//在头节点插入(链表头会改变)if(p->data == data){//判断指定的节点是不是头节点new->nest = p;	//让新节点的next指向pprintf("第一个节点前插入成功，链表头发生改变！\n");return new;		//现在new是新的链表头，return到main函数}//在中间指定节点前插入while(p->nest != NULL){			//因为这里是从中间节点插入，所以会从第二个节点开始遍历链表,直到链表尾NULL时停止if(p->nest->data == data){	//判断当前节点是不是指定节点new->nest = p->nest;	//让要插入新节点的next指向p->next(就是当前节点的下一个节点)p->nest = new;			//在让当前节点next指向要插入的新节点newprintf("插入成功！\n");return hand;			//把链表头return回main函数}p = p->nest;				//使p指向下一节点}printf("插入失败！\n");return hand;
}int main()
{struct Test *hand = NULL;//定义结构体变量，作为节点，给节点赋值struct Test t1 = {1,NULL};struct Test t2 = {2,NULL};struct Test t3 = {3,NULL};struct Test t4 = {4,NULL};struct Test t5 = {5,NULL};t1.nest = &t2;	//将节点t2的地址赋值给t1节点的nestt2.nest = &t3;	//将节点t3的地址赋值给t2节点的nestt3.nest = &t4;	//将节点t4的地址赋值给t3节点的nestt4.nest = &t5;	//将节点t5的地址赋值给t4节点的nesthand = &t1;					//把链表头的地址赋值给handprintf("动态输出链表：\n");printLink(hand);			//把链表头传过去,打印链表struct Test new = {100,NULL};//创建一个新节点newhand = insertFromfront(hand,1,&new);//把链表头,要插入的位置,和新节点new的地址传过去，返回链表头printf("在第一个节点前插入一个新节点：\n");printLink(hand);struct Test new2 = {200,NULL};//创建一个新节点new2hand = insertFromfront(hand,2,&new2);//把链表头,要插入的位置,和新节点new的地址传过去，返回链表头printf("在链表中间指定节点前插入一个新节点：\n");printLink(hand);return 0;
}
/*
E:\code\一阶段C语言\链表>gcc demo_指定节点前方插入新节点.cE:\code\一阶段C语言\链表>a.exe
动态输出链表：
1 2 3 4 5
第一个节点前插入成功，链表头发生改变！
在第一个节点前插入一个新节点：
100 1 2 3 4 5
插入成功！
在链表中间指定节点前插入一个新节点：
100 1 200 2 3 4 5
*/

六、链表删除指定节点

• 链表删除指定节点的两种情况：

1. 判断要删除的节点是不是第一个节点，如果是第一个节点，直接改链表头，让第二个节点成为新的链表头

2. 要删除的节点如果不是第一个结点的话，把要删除节点的前一个节点的nest越过要删除的节点，然后指向要删除的节点下一个节点

• 现在链表是静态创建的，如果链表是动态创建的话，记得把删除节点内存通过free函数释放掉，防止内存泄漏

#include struct Test
{int data;			//数据struct Test *nest;	//指向同类型的指针
};//链表动态遍历输出
void printLink(struct Test *hand)
{struct Test *p = hand;		//p指向链表头while(p != NULL){			//遍历到链表尾巴NULL时，循环结束printf("%d ",p->data);	//输出当前节点data的值p = p->nest;			//p指向下一个节点}putchar('\n');
}//链表删除指定节点
struct Test* deleteNode(struct Test *hand, int data)
{struct Test *p = hand;//删除第一个节点if(p->data == data){				//判断要删除的节点是不是头节点p = p->nest;					//让p指向下一个节点printf("成功删除第一个节点，链表头发生改变！\n");return p;						//把新的链表头return回去}//删除其他节点while(p->nest != NULL){				//从第二个节点开始遍历链表if(p->nest->data == data){		//判断当前节点是不是要删除的节点p->nest = p->nest->nest;	//把要删除节点的前一个节点的next越过要删除的节点，然后指向要删除节点的下一个节点printf("成功删除指定节点！\n");return hand;				//把链表头return回去}p = p->nest;					//p指向下一个节点}return hand;
}int main()
{struct Test *hand = NULL;//定义结构体变量，作为节点，给节点赋值struct Test t1 = {1,NULL};struct Test t2 = {2,NULL};struct Test t3 = {3,NULL};struct Test t4 = {4,NULL};struct Test t5 = {5,NULL};t1.nest = &t2;	//将节点t2的地址赋值给t1节点的nestt2.nest = &t3;	//将节点t3的地址赋值给t2节点的nestt3.nest = &t4;	//将节点t4的地址赋值给t3节点的nestt4.nest = &t5;	//将节点t5的地址赋值给t4节点的nesthand = &t1;					//把链表头的地址赋值给handprintf("动态输出链表：\n");printLink(hand);			//把链表头传过去,打印链表hand = deleteNode(hand,3);	//把链表头，和要删除第几个节点传过去printf("链表动态输出：\n");printLink(hand);			//把链表头传过去,打印链表return 0;
}
/*
E:\code\一阶段C语言\链表>gcc demo_链表删除指定节点.cE:\code\一阶段C语言\链表>a.exe
链表动态输出：
1 2 3 4 5
成功删除第一个节点，链表头发生改变！
链表动态输出：
2 3 4 5E:\code\一阶段C语言\链表>gcc demo_链表删除指定节点.cE:\code\一阶段C语言\链表>a.exe
链表动态输出：
1 2 3 4 5
成功删除指定节点！
链表动态输出：
1 2 4 5E:\code\一阶段C语言\链表>gcc demo_链表删除指定节点.cE:\code\一阶段C语言\链表>a.exe
链表动态输出：
1 2 3 4 5
成功删除指定节点！
链表动态输出：
1 2 3 4E:\code\一阶段C语言\链表>gcc demo_链表删除指定节点.cE:\code\一阶段C语言\链表>a.exe
链表动态输出：
1 2 3 4 5
成功删除指定节点！
链表动态输出：
1 2 4 5
*/

七、改变链表指定节点的数据

#include struct Test
{int data;			//数据struct Test *nest;	//指向同类型的指针
};//链表动态遍历输出
void printLink(struct Test *hand)
{struct Test *p = hand;		//p指向链表头while(p != NULL){			//遍历到链表尾巴NULL时，循环结束printf("%d ",p->data);	//输出当前节点data的值p = p->nest;			//p指向下一个节点}putchar('\n');
}//改变链表指定节点的数据
int gaiLink(struct Test *hand, int data, int newData)
{struct Test *p = hand;while(p != NULL){if(p->data == data){		//找到指定节点p->data = newData;		//改变指定节点的数据return 1;}p = p->nest;}return 0;
}int main()
{int newData;	//要改变的数据int node;		//指定节点struct Test *hand = NULL;//定义结构体变量，作为节点，给节点赋值struct Test t1 = {1,NULL};struct Test t2 = {2,NULL};struct Test t3 = {3,NULL};struct Test t4 = {4,NULL};struct Test t5 = {5,NULL};t1.nest = &t2;	//将节点t2的地址赋值给t1节点的nestt2.nest = &t3;	//将节点t3的地址赋值给t2节点的nestt3.nest = &t4;	//将节点t4的地址赋值给t3节点的nestt4.nest = &t5;	//将节点t5的地址赋值给t4节点的nesthand = &t1;					//把链表头的地址赋值给handprintf("动态输出链表：\n");printLink(hand);			//把链表头传过去,打印链表printf("请输入你要改那个节点的数据：\n");scanf("%d",&node);printf("请输入你要改的数据：\n");scanf("%d",&newData);int ret = gaiLink(hand,node,newData);//把链表头，指定节点和要改变的数据传过去if(ret == 1){printf("数据改变成功！\n");}else{printf("数据改变失败！\n");}printf("数据改变之后输出链表：\n");printLink(hand);return 0;
}
/*
E:\code\一阶段C语言\链表>gcc demo_改变链表指定节点的数据.cE:\code\一阶段C语言\链表>a.exe
链表动态遍历输出：
1 2 3 4 5
请输入你要改那个节点的数据：
2
请输入你要改的数据：
100
数据改变成功！
数据改变之后输出链表：
1 100 3 4 5
*/

八、动态创建链表

• 动态创建链表有两种方式：

1. 头插法

2. 尾插法

8.1 动态创建链表之头插法：

• 刚开始是没有链表的，需要我们动态创建：我们动态创建一个新节点，如果head是NULL那么就让我们的新节点当作链表头，每次创建的新节点插在链表头之前，让新节点当作链表头

#include 
#include struct Test
{int data;			//数据struct Test *nest;	//指向同类型的指针
};//链表动态遍历输出
void printLink(struct Test *head)
{struct Test *p = head;		//p指向链表头while(p != NULL){			//遍历到链表尾巴NULL时，循环结束printf("%d ",p->data);	//输出当前节点data的值p = p->nest;			//p指向下一个节点}putchar('\n');
}//动态创建链表之头插法
struct Test* insertFromHead(struct Test *head, struct Test *new)
{if(head == NULL){		//当没有链表的时候head = new;			//创建的第一个节点当作链表头}else{					//如果链表有其他节点存在new->nest = head;	//创建的新节点的nest指向后面的节点head = new;			//新节点当作链表头}return head;			//return链表头
}//动态创建链表
struct Test* creatLink(struct Test *head)
{struct Test *new;while(1){new = (struct Test *)malloc(sizeof(struct Test));	//创建一个新节点new->nest = NULL;									//新节点的nest指向NULL,否则遍历输出链表会出错printf("创建新节点完成，请输入新节点的数据：\n");	scanf("%d",&(new->data));							//输入新节点的数据if(new->data == 0){									//判断输入新节点的数据是否为0printf("0 quit\n");free(new);										//释放节点数据为0的节点return head;									//停止创建链表，return链表头}head = insertFromHead(head,new);					//新节点当作链表头}return head;											//return链表头
}int main()
{struct Test *head = NULL;head = creatLink(head);					//head指向链表头printf("动态创建链表完成，动态输出链表：\n");printLink(head);struct Test t1 = {100,NULL};head = insertFromHead(head,&t1);printf("随时可以将创建的新节点通过头插法插入到链表中：\n");printLink(head);return 0;
}
/*
E:\code\一阶段C语言\链表>gcc demo_链表动态创建之头插法.cE:\code\一阶段C语言\链表>a.exe
创建新节点完成，请输入新节点的数据：
1
创建新节点完成，请输入新节点的数据：
2
创建新节点完成，请输入新节点的数据：
3
创建新节点完成，请输入新节点的数据：
0
0 quit
动态创建链表完成，动态输出链表：
3 2 1
随时可以将创建的新节点通过头插法插入到链表中：
100 3 2 1
*/

8.2 动态创建链表之尾插法：

• 刚开始是没有链表的，需要我们动态创建：我们动态创建一个新节点，创建的第一个节点当作链表头，然后每一次创建的新节点插在链表最后一个节点的nest中

#include 
#include struct Test
{int data;			//数据struct Test *nest;	//指向同类型的指针
};//链表动态遍历输出
void printLink(struct Test *head)
{struct Test *p = head;		//p指向链表头while(p != NULL){			//遍历到链表尾巴NULL时，循环结束printf("%d ",p->data);	//输出当前节点data的值p = p->nest;			//p指向下一个节点}putchar('\n');
}//动态创建链表之头插法
struct Test* insertBehind(struct Test *head, struct Test *new)
{struct Test *p = head;if(head == NULL){	//当没有链表的时候head = new;		//创建的第一个节点当作链表头return head;	//return链表头}while(p->nest != NULL){	//遍历到最后一个节点p = p->nest;		//p指向下一个节点}p->nest = new;			//创建的新节点插入到最后一个节点的nest中return head;			//return链表头
}//动态创建链表
struct Test* creatLink(struct Test *head)
{struct Test *new;while(1){new = (struct Test *)malloc(sizeof(struct Test));	//创建一个新节点new->nest = NULL;									//新节点的nest指向NULL,否则遍历输出链表会出错printf("创建新节点完成，请输入新节点的数据：\n");scanf("%d",&(new->data));							//输入新节点的数据if(new->data == 0){									//判断输入新节点的数据是否为0printf("0 quit\n");free(new);										//释放节点数据为0的节点return head;									//停止创建链表，return链表头}head = insertBehind(head,new);						//每次动态创建的新节点通过尾插法插入到链表中}return head;											//return链表头
}int main()
{struct Test *head = NULL;head = creatLink(head);printf("动态创建链表完成，动态输出链表：\n");printLink(head);struct Test t1 = {100,NULL};head = insertBehind(head,&t1);printf("随时可以将创建的新节点通过尾插法插入到链表中：\n");printLink(head);return 0;
}
/*
E:\code\一阶段C语言\链表>gcc demo_链表动态创建之尾插法.c -gE:\code\一阶段C语言\链表>a.exe
创建新节点完成，请输入新节点的数据：
1
创建新节点完成，请输入新节点的数据：
2
创建新节点完成，请输入新节点的数据：
3
创建新节点完成，请输入新节点的数据：
0
0 quit
动态创建链表完成，动态输出链表：
1 2 3
随时可以将创建的新节点通过尾插法插入到链表中：
1 2 3 100
*/

九、链表增删改查

#include 
#include struct Test
{int data;struct Test *nest;
};//动态遍历链表
void printLink(struct Test *head)
{struct Test *p = head;while(p != NULL){printf("%d ",p->data);p = p->nest;}putchar('\n');
}//动态创建链表之尾插法
struct Test* insertFromBehind(struct Test *head, struct Test *new)
{struct Test *p = head;if(head == NULL){head = new;return new;}while(p->nest != NULL){p = p->nest;}p->nest = new;return head;
}//动态创建链表
struct Test* creatLink(struct Test *head)
{struct Test *new;while(1){new = (struct Test *)malloc(sizeof(struct Test));new->nest = NULL;printf("动态创建新节点完成，请输入新节点data的数据：\n");scanf("%d",&(new->data));if(new->data == 0){printf("0 quit\n");free(new);return head;}head = insertFromBehind(head,new);}return head;
}//统计链表节点个数
int getLinkTotalNodeNum(struct Test *head)
{struct Test *p = head;int cnt = 0;while(p != NULL){cnt++;p = p->nest;}return cnt;
}//查找链表节点
int searchLink(struct Test *head, int data)
{struct Test *p = head;while(p != NULL){if(p->data == data){return 1;}p = p->nest;}return 0;
}//在指定节点后面插入新节点
int insertFromBehind2(struct Test *head, int data, struct Test *new)
{struct Test *p = head;while(p != NULL){if(p->data == data){new->nest = p->nest;p->nest = new;return 1;}p = p->nest;}return 0;
}//在指定节点前方插入新节点
struct Test* insertFromfront(struct Test *head, int data, struct Test *new)
{struct Test *p = head;if(p->data == data){new->nest = p;printf("在第%d个节点前面插入新节点OK，链表头发生变化！\n",data);return new;}while(p->nest != NULL){if(p->nest->data == data){new->nest = p->nest;p->nest = new;printf("在指定节点%d前面插入新节点OK\n",data);return head;}p = p->nest;}return head;
}//链表删除指定节点
struct Test* deleteNode(struct Test *head, int data)
{struct Test *p = head;if(p->data == data){head = p->nest;free(p);printf("链表的第%d个节点删除完毕，链表头发生变化！\n",data);return head;}while(p->nest != NULL){if(p->nest->data == data){p->nest = p->nest->nest;printf("链表的第%d个节点删除完毕！\n",data);return head;}p = p->nest;}return head;
}//修改链表指定节点的数据
int gaiLink(struct Test *head, int data, int newData)
{struct Test *p = head;while(p != NULL){if(p->data == data){p->data = newData;return 1;}p = p->nest;}return 0;
}int main()
{int cmd;int newData;struct Test *head = NULL;head = creatLink(head);printf("链表动态创建完成，遍历输出：\n");printLink(head);int ret = getLinkTotalNodeNum(head);printf("链表的节点个数：%d\n",ret);printf("请输入你要查找哪一个节点数据：\n");scanf("%d",&cmd);ret = searchLink(head,cmd);if(ret == 1){printf("可以找到:%d\n",cmd);}else{printf("找不到%d\n",cmd);}printf("请输入你要查找哪一个节点数据：\n");scanf("%d",&cmd);ret = searchLink(head,cmd);if(ret == 1){printf("可以找到:%d\n",cmd);}else{printf("找不到%d\n",cmd);}struct Test new = {100,NULL};printf("请输入你要插在哪一个节点后面：\n");scanf("%d",&cmd);ret = insertFromBehind2(head,cmd,&new);if(ret == 1){printf("在指定节点%d后面插入新节点OK\n",cmd);}else{printf("在指定节点%d后面插入新节点失败\n",cmd);}printf("在指定节点后面插入新节点后遍历输出链表：\n");printLink(head);struct Test new2 = {200,NULL};printf("请输入你要插在哪一个节点的前面：\n");scanf("%d",&cmd);head = insertFromfront(head,cmd,&new2);printf("链表在指定节点前方插入新节点OK，遍历输出：\n");printLink(head);printf("请输入你要删除哪一个节点：\n");scanf("%d",&cmd);head = deleteNode(head,cmd);printf("链表删除指定节点后，输出链表：\n");printLink(head);printf("请输入你要改哪一个节点data的数据：\n");scanf("%d",&cmd);printf("请输入要更改的数据：\n");scanf("%d",&newData);ret = gaiLink(head,cmd,newData);if(ret == 1){printf("指定节点的数据修改成功！\n");}else{printf("指定节点的数据修改失败！\n");}printf("链表修改指定节点data的数据后，遍历输出链表：\n");printLink(head);return 0;
}
/*
E:\code\一阶段C语言\链表>gcc demo_链表.c -gE:\code\一阶段C语言\链表>a.exe
动态创建新节点完成，请输入新节点data的数据：
1
动态创建新节点完成，请输入新节点data的数据：
2
动态创建新节点完成，请输入新节点data的数据：
3
动态创建新节点完成，请输入新节点data的数据：
4
动态创建新节点完成，请输入新节点data的数据：
5
动态创建新节点完成，请输入新节点data的数据：
0
0 quit
链表动态创建完成，遍历输出：
1 2 3 4 5
链表的节点个数：5
请输入你要查找哪一个节点数据：
1
可以找到:1
请输入你要查找哪一个节点数据：
8
找不到8
请输入你要插在哪一个节点后面：
5
在指定节点5后面插入新节点OK
在指定节点后面插入新节点后遍历输出链表：
1 2 3 4 5 100
请输入你要插在哪一个节点的前面：
3
在指定节点3前面插入新节点OK
链表在指定节点前方插入新节点OK，遍历输出：
1 2 200 3 4 5 100
请输入你要删除哪一个节点：
2
链表的第2个节点删除完毕！
链表删除指定节点后，输出链表：
1 200 3 4 5 100
请输入你要改哪一个节点data的数据：
200
请输入要更改的数据：
1000
指定节点的数据修改成功！
链表修改指定节点data的数据后，遍历输出链表：
1 1000 3 4 5 100
*/