目录
一、链表的概念
1.1 什么是链表：
-
链表是一种数据结构，是一种数据存放的思想.
二、链表和数组的区别：
-
数组静态分配内存，链表动态分配内存
-
数组在内存中是连续的，链表是不连续的
-
数组利用下标定位，链表通过遍历定位元素
-
数组插入和删除需要移动其他元素，链表的插入或删除不需要移动其他元素
2.1 链表和数组的优缺点：
2.1.1 数组的优缺点：
-
随机访问性比较强，可以通过下标进行快速定位。
-
查找速度快
-
插入和删除的效率低，需要移动其他元素。
-
会造成内存的浪费，因为内存是连续的，所以在申请数组的时候就必须规定内存的大小，如果不合适，就会造成内存的浪费。
-
内存空间要求高，创建一个数组，必须要有足够的连续内存空间。
-
数组的大小是固定的，在创建数组的时候就已经规定好，不能动态拓展。
2.1.2 链表的优缺点：
-
插入和删除的效率高，只需要改变指针的指向就可以进行插入和删除。
-
内存利用率高，不会浪费内存，可以使用内存中细小的不连续的空间，只有在需要的时候才去创建空间。大小不固定，拓展很灵活。
-
查找的效率低，因为链表是从第一个节点向后遍历查找。
#include <stdio.h>
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; i<len; i++){
printf("%d ",arr[i]);
}
putchar('\n');
struct Test t1 = {1,NULL};
struct Test t2 = {2,NULL};
struct Test t3 = {3,NULL};
t1.nest = &t2;
t2.nest = &t3;
printf("use t1 to print three nums\n");
printf("%d %d %d\n",t1.data,t1.nest->data,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 <stdio.h>
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节点的nest
t2.nest = &t3; //将节点t3的地址赋值给t2节点的nest
t3.nest = &t4; //将节点t4的地址赋值给t3节点的nest
printf("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 <stdio.h>
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节点的nest
t2.nest = &t3; //将节点t3的地址赋值给t2节点的nest
t3.nest = &t4; //将节点t4的地址赋值给t3节点的nest
t4.nest = &t5; //将节点t5的地址赋值给t4节点的nest
printf("链表动态输出：\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.c
E:\code\一阶段C语言\链表>a.exe
链表动态输出：
1 2 3 4 5
链表的节点个数是：5
找到1了
没有找到8
*/五、链表插入
-
关于链表的插入有两种方式：
-
第一种：从指定节点后方插入新节点
-
第二种：从指定指点前方插入新节点
5.1 链表从指定节点后方插入新节点：
#include <stdio.h>
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节点的nest
t2.nest = &t3; //将节点t3的地址赋值给t2节点的nest
t3.nest = &t4; //将节点t4的地址赋值给t3节点的nest
t4.nest = &t5; //将节点t5的地址赋值给t4节点的nest
hand = &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_指定节点后方插入新节点.c
E:\code\一阶段C语言\链表>a.exe
链表动态遍历：
1 2 3 4 5
插入成功！
1 2 3 100 4 5
*/5.2 链表从指定节点前方插入新节点：
如果要在指定节点前插入新节点的话，需要考虑两种情况：
-
在第一个节点前插入新节点
-
在中间指定节点前插入新节点
#include <stdio.h>
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指向p
printf("第一个节点前插入成功，链表头发生改变！\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指向要插入的新节点new
printf("插入成功！\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节点的nest
t2.nest = &t3; //将节点t3的地址赋值给t2节点的nest
t3.nest = &t4; //将节点t4的地址赋值给t3节点的nest
t4.nest = &t5; //将节点t5的地址赋值给t4节点的nest
hand = &t1; //把链表头的地址赋值给hand
printf("动态输出链表：\n");
printLink(hand); //把链表头传过去,打印链表
struct Test new = {100,NULL};//创建一个新节点new
hand = insertFromfront(hand,1,&new);//把链表头,要插入的位置,和新节点new的地址传过去，返回链表头
printf("在第一个节点前插入一个新节点：\n");
printLink(hand);
struct Test new2 = {200,NULL};//创建一个新节点new2
hand = insertFromfront(hand,2,&new2);//把链表头,要插入的位置,和新节点new的地址传过去，返回链表头
printf("在链表中间指定节点前插入一个新节点：\n");
printLink(hand);
return 0;
}
/*
E:\code\一阶段C语言\链表>gcc demo_指定节点前方插入新节点.c
E:\code\一阶段C语言\链表>a.exe
动态输出链表：
1 2 3 4 5
第一个节点前插入成功，链表头发生改变！
在第一个节点前插入一个新节点：
100 1 2 3 4 5
插入成功！
在链表中间指定节点前插入一个新节点：
100 1 200 2 3 4 5
*/六、链表删除指定节点
-
链表删除指定节点的两种情况：
-
判断要删除的节点是不是第一个节点，如果是第一个节点，直接改链表头，让第二个节点成为新的链表头
-
要删除的节点如果不是第一个结点的话，把要删除节点的前一个节点的nest越过要删除的节点，然后指向要删除的节点下一个节点
-
现在链表是静态创建的，如果链表是动态创建的话，记得把删除节点内存通过free函数释放掉，防止内存泄漏
#include <stdio.h>
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节点的nest
t2.nest = &t3; //将节点t3的地址赋值给t2节点的nest
t3.nest = &t4; //将节点t4的地址赋值给t3节点的nest
t4.nest = &t5; //将节点t5的地址赋值给t4节点的nest
hand = &t1; //把链表头的地址赋值给hand
printf("动态输出链表：\n");
printLink(hand); //把链表头传过去,打印链表
hand = deleteNode(hand,3); //把链表头，和要删除第几个节点传过去
printf("链表动态输出：\n");
printLink(hand); //把链表头传过去,打印链表
return 0;
}
/*
E:\code\一阶段C语言\链表>gcc demo_链表删除指定节点.c
E:\code\一阶段C语言\链表>a.exe
链表动态输出：
1 2 3 4 5
成功删除第一个节点，链表头发生改变！
链表动态输出：
2 3 4 5
E:\code\一阶段C语言\链表>gcc demo_链表删除指定节点.c
E:\code\一阶段C语言\链表>a.exe
链表动态输出：
1 2 3 4 5
成功删除指定节点！
链表动态输出：
1 2 4 5
E:\code\一阶段C语言\链表>gcc demo_链表删除指定节点.c
E:\code\一阶段C语言\链表>a.exe
链表动态输出：
1 2 3 4 5
成功删除指定节点！
链表动态输出：
1 2 3 4
E:\code\一阶段C语言\链表>gcc demo_链表删除指定节点.c
E:\code\一阶段C语言\链表>a.exe
链表动态输出：
1 2 3 4 5
成功删除指定节点！
链表动态输出：
1 2 4 5
*/七、改变链表指定节点的数据
#include <stdio.h>
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节点的nest
t2.nest = &t3; //将节点t3的地址赋值给t2节点的nest
t3.nest = &t4; //将节点t4的地址赋值给t3节点的nest
t4.nest = &t5; //将节点t5的地址赋值给t4节点的nest
hand = &t1; //把链表头的地址赋值给hand
printf("动态输出链表：\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_改变链表指定节点的数据.c
E:\code\一阶段C语言\链表>a.exe
链表动态遍历输出：
1 2 3 4 5
请输入你要改那个节点的数据：
2
请输入你要改的数据：
100
数据改变成功！
数据改变之后输出链表：
1 100 3 4 5
*/八、动态创建链表
-
动态创建链表有两种方式：
-
头插法
-
尾插法
8.1 动态创建链表之头插法：
-
刚开始是没有链表的，需要我们动态创建：我们动态创建一个新节点，如果head是NULL那么就让我们的新节点当作链表头，每次创建的新节点插在链表头之前，让新节点当作链表头
#include <stdio.h>
#include <stdlib.h>
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){ //判断输入新节点的数据是否为0
printf("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_链表动态创建之头插法.c
E:\code\一阶段C语言\链表>a.exe
创建新节点完成，请输入新节点的数据：
1
创建新节点完成，请输入新节点的数据：
2
创建新节点完成，请输入新节点的数据：
3
创建新节点完成，请输入新节点的数据：
0
0 quit
动态创建链表完成，动态输出链表：
3 2 1
随时可以将创建的新节点通过头插法插入到链表中：
100 3 2 1
*/8.2 动态创建链表之尾插法：
-
刚开始是没有链表的，需要我们动态创建：我们动态创建一个新节点，创建的第一个节点当作链表头，然后每一次创建的新节点插在链表最后一个节点的nest中
#include <stdio.h>
#include <stdlib.h>
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){ //判断输入新节点的数据是否为0
printf("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 -g
E:\code\一阶段C语言\链表>a.exe
创建新节点完成，请输入新节点的数据：
1
创建新节点完成，请输入新节点的数据：
2
创建新节点完成，请输入新节点的数据：
3
创建新节点完成，请输入新节点的数据：
0
0 quit
动态创建链表完成，动态输出链表：
1 2 3
随时可以将创建的新节点通过尾插法插入到链表中：
1 2 3 100
*/九、链表增删改查
#include <stdio.h>
#include <stdlib.h>
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 -g
E:\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
*/
2656
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
