C语言数据结构：链表的增删改查及动态创建

已于 2023-03-12 17:51:28 修改
阅读量2k 收藏 56
点赞数 29
分类专栏： C语言 数据结构 文章标签： 数据结构 链表 c语言
于 2023-03-10 19:27:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74985965/article/details/129429745
版权

目录

一，链表与数组

① 定义区别

② 实现区别

二，链表遍历和计算链表中节点数量

① 链表遍历

② 计算节点数量

三，查找链表节点

四，增加节点到链表中

① 在节点后方插入

② 在节点前方插入

● 在头节点前方插入

● 在其他节点前方插入

五，删除链表中指定的节点

① 删除链表头节点

② 删除链表其它节点

六，修改链表中指定的节点

七，动态创建链表

① 头插法创建链表

② 尾插法创建链表

一，链表与数组

① 定义区别

数组：数组是在内存中连续存储的具有相同类型的一组数据的集合

      ● 数组中数的类型必须相同；

      ● 数组中数在内存中必须是连续存储的

链表：把它想象成自行车链条，由n个节点组成，可以对这些节点进行“增，删，改，查”等操作，即对数据的操作。

      ● 可以进行动态存储分配；

      ● 可以在节点中定义多种数据类型；

      ● 用NULL来表示空节点；

      ● 链表都有一个头指针，一般以head来表示，存放的是一个地址；

      ● 链表中包含头结点和其它节点两种，头结点是没有数据域的；

      ● 链表中每个节点都分为两个区域，一个数据域，一个是指针域；

② 实现区别

数组：

#include <stdio.h>

int main()
{
        int i;
        int arr[] = {1,2,3,4,5,6,7,8};
        int len = sizeof(arr)/sizeof(arr[0]);

        for(i=0;i<len;i++){
                printf("%d ",arr[i]);
        }
        putchar('\n');
        printf("number=%d\n",len);
        return 0;
}
dhw@dhw-virtual-machine:~$ ./a.out
1 2 3 4 5 6 7 8 
number=8

链表：

#include <stdio.h>

struct Test{
        int data;
        struct Test *next;
};

int main()
{
        struct Test t1 = {1,NULL};
        struct Test t2 = {2,NULL};
        struct Test t3 = {3,NULL};
        struct Test t4 = {4,NULL};

        t1.next = &t2; //t1节点的下一个节点为&t2，因为struct Test *next,所以要取地址
        t2.next = &t3; //t2节点的下一个节点为&t3
        t3.next = &t4; //t3节点的下一个节点为&t4

        printf("%d %d %d %d\n",t1.data,t1.next->data,t1.next->next->data,t1.next->next->next->data);
        //此处以结构体的方式打印，用来引入链表主题
        return 0;
}
dhw@dhw-virtual-machine:~$ ./a.out
1 2 3 4

二，链表遍历和计算链表中节点数量

① 链表遍历

struct Test *p = head;              //定义链表头
        while(p != NULL){           //如果链表头不为空
                printf("%d ",p->data);  //就先打印链头的值
                p = p->next;        //一直链接下一个数的值，不断打印，直到节点值为NULL就停止
#include <stdio.h>

struct Test{
        int data;
        struct Test *next;
};

void printLink(struct Test *head)
{
        struct Test *p = head;      //定义链表头
        while(p != NULL){           //如果链表头不为空
                printf("%d ",p->data);  //就先打印链头的值
                p = p->next;        //一直链接下一个数的值，不断打印，直到节点值为NULL就停止
        }
        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.next = &t2;
        t2.next = &t3;
        t3.next = &t4;

        printLink(&t1); //此处t1就是链头，要取链表头的地址
        return 0;
}

dhw@dhw-virtual-machine:~$ ./a.out
1 2 3 4

② 计算节点数量

int cnt = 0;  //接收链表数量       
        struct Test *p = head;
        while(p != NULL){  //如果链头不为空，那么cnt++直到链尾出现NULL就停止
                cnt++;    
                p = p->next;
        }
        return cnt; //返回值取cnt
#include <stdio.h>

struct Test{
        int data;
        struct Test *next;
};

void printLink(struct Test *head)
{
        struct Test *p = head;
        while(p != NULL){
                printf("%d ",p->data);   //遍历链表部分
                p = p->next;
        }
        putchar('\n');
}

int numLinkList(struct Test *head)
{
        int cnt = 0;  //接收链表数量       
        struct Test *p = head;
        while(p != NULL){  //如果链头不为空，那么cnt++直到链尾出现NULL就停止
                cnt++;    
                p = p->next;
        }
        return cnt; //返回值取cnt
}
int main()
{
        int ret;
        struct Test t1 = {1,NULL};
        struct Test t2 = {2,NULL};
        struct Test t3 = {3,NULL};
        struct Test t4 = {4,NULL};

        t1.next = &t2;
        t2.next = &t3;
        t3.next = &t4;

        printLink(&t1); //遍历链表

        ret = numLinkList(&t1);  //t1为链头，该函数传参就传t1的地址
        printf("num = %d\n",ret);
        return 0;
}
dhw@dhw-virtual-machine:~$ ./a.out
1 2 3 4 
num = 4

三，查找链表节点

int searchLinklist(struct Test *head,int n)//定义n为要查找的节点
{
        struct Test *p = head;
        while(p != NULL){
                if(p->data == n){   //如果头节点就是我们要查找的节点
                        return 1;   //那么返回值为1，表示找到
                }
                p = p->next;  //否者就继续往下一个节点查找，直到找到或者节点为空就停止
        }
        return 0;        //一直没找到就返回0；
}
#include <stdio.h>

struct Test{
        int data;
        struct Test *next;
};

void printLink(struct Test *head)
{
        struct Test *p = head;
        while(p != NULL){
                printf("%d ",p->data); //遍历链表部分
                p = p->next;
        }
        putchar('\n');
}

int searchLinklist(struct Test *head,int n)
{
        struct Test *p = head;
        while(p != NULL){
                if(p->data == n){   //如果头节点就是我们要查找的节点
                        return 1;   //那么返回值为1，表示找到
                }
                p = p->next;  //否者就继续往下一个节点查找，直到找到或者节点为空就停止
        }
        return 0;        //一直没找到就返回0；
}
int main()
{
        int ret;

        struct Test t1 = {1,NULL};
        struct Test t2 = {2,NULL};
        struct Test t3 = {3,NULL};
        struct Test t4 = {4,NULL};

        t1.next = &t2;
        t2.next = &t3;
        t3.next = &t4;

        printLink(&t1);//遍历链表
        ret = searchLinklist(&t1,3); //查找3这个节点
        if(ret == 1){    //如果返回值为1
                printf("have 3\n"); //就查找到3这个节点
        }else{
                printf("no 3\n");  //否者就没有3这个节点
        }

        ret = searchLinklist(&t1,7); //查找7这个节点
        if(ret == 1){
                printf("have 7\n");
        }else{
                printf("no 7\n");
        }
        return 0;
}
dhw@dhw-virtual-machine:~$ ./a.out
1 2 3 4   //遍历出来的链表节点
have 3    //查找到有3这个节点
no 7      //没有查找到7这个节点

四，增加节点到链表中

① 在节点后方插入

逻辑分析：

● 函数中需要定义新插入的节点new，和在哪个节点后插入n；

● 遍历链表，找到要插入的节点位置；while(p != NULL){p = p->next;}

● 如果链头就是要找的那个节点:p->data == n;

● 新节点的下一个=找的那个节点的下一个：new->next = p->next

● 找的那个节点的下一个节点就是新插入的节点：p->next = new; 

#include <stdio.h>

struct Test{
        int data;
        struct Test *next;
};

void printLink(struct Test *head)   //遍历链表部分
{
        struct Test *p = head;
        while(p != NULL){
                printf("%d ",p->data);
                p = p->next;
        }
        putchar('\n');
}

void searchBehindLink(struct Test *head,struct Test *new,int n)
{                                    //new为新节点，n为要在哪个节点后插入节点
        struct Test *p = head;
        while(p != NULL){    //需要遍历步骤，找到要在那个节点后方插入节点      
                if(p->data == n){ //如果链头的值就是要找的那个节点
                        new->next = p->next; //新节点的下一个=找的那个节点的下一个
                        p->next = new; //找的那个节点的下一个就是新插入的节点
                }
                p = p->next;
        }
}
int main()
{
        int ret;

        struct Test t1 = {1,NULL};
        struct Test t2 = {2,NULL};
        struct Test t3 = {3,NULL};
        struct Test t4 = {4,NULL};
        struct Test new = {100,NULL}; //定义要插入的节点，插入的数是100

        t1.next = &t2;
        t2.next = &t3;
        t3.next = &t4;

        printLink(&t1);//遍历
        searchBehindLink(&t1,&new,3);//在节点3后面插入新节点100
        printLink(&t1);//插入新节点后在遍历一次，看是否插入成功
        return 0;
}
dhw@dhw-virtual-machine:~$ ./a.out
1 2 3 4         //原先的节点数
1 2 3 100 4     //插入成功，在3节点后方插入100

② 在节点前方插入

● 在头节点前方插入

如果在头结点插入新节点，那么头节点的地址就会发生改变，需要定义指针变量来接收新的头结点地址。

#include <stdio.h>

struct Test{
        int data;
        struct Test *next;
};

void printLink(struct Test *head) //遍历链表部分
{
        struct Test *p = head;
        while(p != NULL){
                printf("%d ",p->data);
                p = p->next;
        }
        putchar('\n');
}

struct Test *searchFrontLink(struct Test *head,struct Test *new,int n)
{
        struct Test *p = head;
        if(p->data == n){  //链表头的前方插入
                new->next = p; //直接让新节点new->next等于现在的头就行了
                return new; //返回一个new
        }
}
int main()
{
        int ret;

        struct Test t1 = {1,NULL};
        struct Test t2 = {2,NULL};
        struct Test t3 = {3,NULL};
        struct Test t4 = {4,NULL};
        struct Test new = {102,NULL}; //插入102
        struct Test *head = NULL;

        t1.next = &t2;
        t2.next = &t3;
        t3.next = &t4;

        head = &t1;
        printLink(head);//遍历链表
        head = searchFrontLink(head,&new,1);//返回的是new，main函数中的头发生改变，重新用head来接收
        printLink(head);//添加完成，再次遍历链表，验证是否插入成功
        return 0;
}
dhw@dhw-virtual-machine:~$ ./a.out
1 2 3 4      //遍历链表
102 1 2 3 4  //在头节点前方插入新节点102，插入成功

● 在其他节点前方插入

struct Test *searchFrontLink(struct Test *head,struct Test *new,int n)
{
        struct Test *p = head;
        while(p->next != NULL){ //此时没有在链头的前方插入，所以要定义链头的下一个不为NULL
                if(p->next->data == n){   //链头的下一个节点就是我们要找的节点
                        new->next = p->next; //插入进来的新节点就是头节点的下一个
                        p->next = new; //头节点的下一个就是新节点
                        return p; //此时要返回到头
                } 
                p = p->next;

        }
        return p; //返回头节点
}
#include <stdio.h>

struct Test{
        int data;
        struct Test *next;
};

void printLink(struct Test *head)
{
        struct Test *p = head;
        while(p != NULL){
                printf("%d ",p->data);
                p = p->next;
        }
        putchar('\n');
}

struct Test *searchFrontLink(struct Test *head,struct Test *new,int n)
{
        struct Test *p = head;
        while(p->next != NULL){ //此时没有在链头的前方插入，所以要定义链头的下一个不为NULL
                if(p->next->data == n){   //链头的下一个节点就是我们要找的节点
                        new->next = p->next; //插入进来的新节点就是头节点的下一个
                        p->next = new; //头节点的下一个就是新节点
                        return p; //此时要返回到头
                } 
                p = p->next;

        }
        return p; //返回头节点
}
int main()
{
        int ret;

        struct Test t1 = {1,NULL};
        struct Test t2 = {2,NULL};
        struct Test t3 = {3,NULL};
        struct Test t4 = {4,NULL};
        struct Test new = {102,NULL}; //插入新节点102
        struct Test *head = NULL;

        t1.next = &t2;
        t2.next = &t3;
        t3.next = &t4;

        head = &t1;
        printLink(head);
        searchFrontLink(head,&new,3); //插在节点3的前面
        printLink(head);
        return 0;
}
dhw@dhw-virtual-machine:~$ ./a.out
1 2 3 4 
1 2 102 3 4  //在节点3的前面插入新节点102

五，删除链表中指定的节点

删除节点后，内存中会存在残留的缓存数据，需要使用free()来释放地址空间，而free()一般是需要承接malloc()动态开辟了的地址空间。

① 删除链表头节点

逻辑分析：

● 删除的是头节点，所以不需要遍历；

● 确定头节点就是我们要删除的节点：p->data == n;

● 那么新的头节点就是原来头节点的下一个节点：head = head->next;

● 释放删除节点的内存空间：free()；

● 删除链头，链头地址发生改变，需要返回新的链头

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

struct Test{
        int data;
        struct Test *next;
};

void printLink(struct Test *head)
{
        struct Test *p = head;
        while(p != NULL){
                printf("%d ",p->data);
                p = p->next;
        }
        putchar('\n');
}

struct Test *deletLink(struct Test *head,int n)
{
        struct Test *p = head;
        if(p->data == n){  //如果头节点的值就是我们要删除的节点
                head = head->next; //那么新的头节点就是原来头节点的下一个节点
                free(p); //删除了节点就要释放删除节点的内存
                return head;//链头被删除，头发生了改变，就要返回新链头
        }
}
int main()
{
        int ret;

        struct Test t1 = {1,NULL};
        struct Test t2 = {2,NULL};
        struct Test t3 = {3,NULL};
        struct Test t4 = {4,NULL};
        struct Test *head = NULL;
        struct Test *p = (struct Test *)malloc(sizeof(struct Test));//动态开辟链头地址空间
//      t1.next = &t2;
        p->data = 1;//头节点里的值为1
        p->next = &t2;//头节点的下一个节点为t2
        t2.next = &t3;
        t3.next = &t4;

//      head = &t1;
        head = p;
        printLink(head);
        head = deletLink(head,1);//头发生该表，需要新的链头来承接链表头
        printLink(head);
        return 0;
}
dhw@dhw-virtual-machine:~$ ./a.out
1 2 3 4 
2 3 4     //头结点1被删除

② 删除链表其它节点

逻辑分析：

● 遍历链表，遍历出要删除的其它节点;

● 因为不是删链头，所以循环遍历的条件为：p->next != NULL;

● 找到要删除的节点：p->next->data == n;

● 返回值为链头

#include <stdio.h>

struct Test{
        int data;
        struct Test *next;
};

void printLink(struct Test *head)
{
        struct Test *p = head;
        while(p != NULL){
                printf("%d ",p->data);
                p = p->next;
        }
        putchar('\n');
}

struct Test *deletLink(struct Test *head,int n)
{
        struct Test *p = head;
        while(p->next != NULL){  //不是删除头节点，所以定义头节点的下一个节点不为NULL
                if(p->next->data == n){  //如果头节点的下一个节点就是我们要删除的节点
                        p->next = p->next->next; //那么头节点的下一个就是头节点下一个的下一个
                        return head;
                }
                p = p->next;
        }
}
int main()
{
        int ret;

        struct Test t1 = {1,NULL};
        struct Test t2 = {2,NULL};
        struct Test t3 = {3,NULL};
        struct Test t4 = {4,NULL};
        struct Test *head = NULL;

        t1.next = &t2;
        t2.next = &t3;
        t3.next = &t4;

        head = &t1;
        printLink(head);
        head = deletLink(head,2);
        printLink(head);
        return 0;
}

dhw@dhw-virtual-machine:~$ ./a.out
1 2 3 4 
1 3 4    //节点2被删除

六，修改链表中指定的节点

int changeLink(struct Test *head,struct Test *new,int n)
{
        struct Test *p = head;
        while(p != NULL){   //遍历
                if(p->data == n){ //如果头结点的data就是我们=要改变的节点n
                        p->data = new->data;//那么找到的节点数据就等于要改的数据
                        return 1;//返回1，修改成功
                }
                p = p->next;//没有找到那个节点，就一直遍历到NULL节点停止
        }
}
#include <stdio.h>

struct Test{
        int data;
        struct Test *next;
};

void printLink(struct Test *head)
{
        struct Test *p = head;
        while(p != NULL){
                printf("%d ",p->data);
                p = p->next;
        }
        putchar('\n');
}

int changeLink(struct Test *head,struct Test *new,int n)
{
        struct Test *p = head;
        while(p != NULL){   //遍历
                if(p->data == n){ //如果头结点的data就是我们=要改变的节点n
                        p->data = new->data;//那么找到的节点数据就等于要改的数据
                        return 1;//返回1，修改成功
                }
                p = p->next;//没有找到那个节点，就一直遍历到NULL节点停止
        }
}
int main()
{
        struct Test t1 = {1,NULL};
        struct Test t2 = {2,NULL};
        struct Test t3 = {3,NULL};
        struct Test t4 = {4,NULL};
        struct Test *head = NULL;
        struct Test new = {9,NULL};//要改成的节点为9

        t1.next = &t2;
        t2.next = &t3;
        t3.next = &t4;

        head = &t1;
        printLink(head);
        changeLink(head,&new,3);//修改节点3为节点9
        printLink(head);
        return 0;
}
dhw@dhw-virtual-machine:~$ ./a.out
1 2 3 4 
1 2 9 4  //将节点3改为节点9，如果修改头节点也没有问题

七，动态创建链表

① 头插法创建链表

每一次创建的新节点插入在上一个头节点之前，再让新创建的节点为链头

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

struct Test//声明结构体类型
{
        int data;//定义数据域
        struct Test *next;//定义指针域
};

void printLink(struct Test *head)//遍历链表
{
        struct Test *p = head;

        while(p != NULL){//如果链头不为空,
                printf("%d ",p->data);//输出p节点中data的值
                p = p->next;//p指向下一节点，会不断指向链表尾NULL时停止
        }
        putchar('\n');//换行
}

struct Test* insertFromHead(struct Test *head,struct Test* new)
{

        if(head == NULL){//判断头节点是否为空
                head = new;//如果为空直接把创建的新节点当作链表头
        }else{
                new->next = head;//当链表不为空时，新节点的下一个节点为原先的头节点，此时，新节点为头
                head = new;//新节点成为链表头
        }
        return head;//头节点被改变，返回新的头节点
}

struct Test* creatLink(struct Test* head,struct Test *new)//头插法动态创建链表
{
        while(1){
                new = (struct Test*)malloc(sizeof(struct Test));//不断为新节点开辟空间
                printf("input your ne node data:\n");
                scanf("%d",&(new->data));//输入新节点
                if(new->data == 0){//判断每次输入的值是否为0，如果为0，停止创建并退出
                        printf("quit!\n");
                        free(new);//不断为新节点开辟内存空间，就要不断的释放空间
                        return head;//不断的头插，不断的返回新头
                }
                head = insertFromHead(head,new);//调用上面的判断函数
        }
        return head;//头被改变，返回新头
}

int main()
{
        struct Test *head = NULL;
        struct Test *new = NULL;
        head = creatLink(head,new);//head来承接不断被改变的新头
        printLink(head);//遍历链表

        return 0;
}

dhw@dhw-virtual-machine:~$ ./a.out
input your ne node data:
1
input your ne node data:
2
input your ne node data:
3
input your ne node data:
4
input your ne node data:
5
input your ne node data:
6
input your ne node data:
0     //输入0就退出程序
quit!
6 5 4 3 2 1  //从头插入，每一个新插入的节点都为链表头

② 尾插法创建链表

如果头节点为空，那么创建的第一个节点就当做链表头，后面每次创建的新节点都依次插在链表最后一个节点的后面

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

struct Test
{
        int data;//定义数据域
        struct Test *next;//定义指针域
};

void printLink(struct Test *head)//遍历链表
{
        struct Test *p = head;
        while(p != NULL){//p现在是链表头,
                printf("%d ",p->data);//输出p节点中data的值
                p = p->next;//链头不断指向下一节点，直到链表尾NULL时停止
        }
        printf("\n");
}

struct Test* insertBehind(struct Test *head,struct Test *new)
{
        struct Test *p = head;

        if(p == NULL){//判断链表是否为空
                return head = new;//如果为空把创建的新节点当作链表头
        }
        while(p->next != NULL){//遍历到最后一个节点
                p = p->next;//使p指向下一节点
        }
        p->next = new;//把新节点插入最后一个节点的指针域(next)中
        return head;//把链表头传回去
}

struct Test* creatLink(struct Test *head)//尾插法动态创建链表
{
        struct Test *new;
        while(1){
                new = (struct Test *)malloc(sizeof(struct Test));//开辟空间
                new->next = NULL;
                printf("input your ne node data:\n");
                scanf("%d",&(new->data));//输入新节点
                if(new->data == 0){//判断每次输入的值是否为0，如果为0，停止创建并退出
                        printf("quit!\n");
                        return head;//返回到头
                }
                head = insertBehind(head,new);
        }
}

int main()
{
        struct Test *head = NULL;
        head = creatLink(head);
        printLink(head);

}
dhw@dhw-virtual-machine:~$ ./a.out
input your ne node data:
1
input your ne node data:
2
input your ne node data:
3
input your ne node data:
4
input your ne node data:
5
input your ne node data:
6
input your ne node data:
0      //输入0就退出程序
quit!
1 2 3 4 5 6  //按创建节点的顺序，新节点依次往后排列
D.•
关注
  • 29
    点赞
  • 踩
  • 56
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 22
    评论
专栏目录
C语言数据结构库（队列，栈，链表，树的增删改查）
07-09
本库为C语言（Linux环境下编写的适用于所有C的数据结构库函数）。包括了最基础也是最常用的增删改查功能函数，队列，栈，链表（单链表，双链表，循环链表等都有），树的增删改查函数。程序可靠。
创建一个动态链表
bosslin1的博客
04-05 2102
创建函数 struct student *creat() { struct student*head; struct student*p1,*p2; p1=p2=(struct student*)malloc(LEN);//开创空间 printf("输入num\n"); scanf("%d",&p1->num); printf("输入score\n"); scanf("%f",&p1->score); head=NULL; n=0; while(p1-&g.
C语言链表的定义、遍历、增删改查、以及动态创建链表的头插法和尾插法
学习记录，交流学习
03-04 926
一、数组和链表 1、什么是链表 链表是一种常见的重要的数据结构，是一种存放数据的思想，它是动态地进行存储分配的一种结构，当我们用数组存放数据时必须事先定义固定的数组长度（元素个数），并且容易浪费空间，比如在不知道元素个数时，就必须把数组定义得足够大，以便能存下数据，显然这样非常浪费内存。链表就没有这种缺点，它根据需要来开辟空间。 2、链表和数组的区别 首先定义一个数组 int array[10]，array[0]存放1、array[1]存放2，依次存放到array[9] = 10 可以看到数组存放数据都是
用C语言实现链表（增删改查）
最新发布
2201_75849076的博客
03-15 267
记录用C语言实现链表的创建和增删改查
C语言实例-双向链表增删改查
09-11
双向链表（Doubly Linked List）是一种常见的数据结构，在单链表的基础上增加了向前遍历的功能。与单向链表不同，双向链表的每个节点除了包含指向下一个节点的指针外，还包含指向前一个节点的指针。
用c语言实现链表增删改查
11-07
自己写的，能够使用，对c语言的指针用的淋漓精致，有需要的小伙伴可以下载看下
动态创建链表
2301_78772787的博客
11-03 350
动态创建链表的好处动态创建链表的好处相比于之前链表的几种功能介绍，都是在设定好的链表基础之上进行插入、删除等，那么如果我们要创建链表元素很多，就得去定义很多个元素结构体，非常不方便，这个时候应该用到。动态创建链表关键字就是创建，顾名思义就是，相应操作是一个一个分配结点内存空间，然后输入结点中的数据，并建立结点间的相连关系。动态创建链表的方法输入一个新结点并进行内存空间分配，同时进行判断，若为空指针则，返回链表头head；若不为空指针则将其作为链表头head，同时在输入下个结点时，将，同时让。
动态链表创建及操作（对静态的补充）
lzh201864031的博客
04-08 662
tip1：这两个程序很相近，我们都可以分为两个函数，第一个就是头插法或尾插法的API1，它们只负责：①建立新节点new和原先链表head的联系，②注明节点序号。tip2：第二个是批量初始化动态节点的API2，它们负责：①循环开辟新节点new，②键盘输入初始化新节点new中的数据idata，③把head和new打包给API1。
C语言之动态创建链表的两种方式
weixin_51976284的博客
04-14 2676
之前我们说的链表是基于静态创建的，但静态创建的链表很不灵活而且在工作中的项目中的很多场景都不适合，所以我们来记录一下链表的两种动态创建的方式。 1.方式一：链表动态创建之头插法 那么我们直接上代码讲： struct Test* insertLinkfrontHead(struct Test *head,struct Test *new) {//动态创建链表之头插法 if(head == NULL) { head = new; } else { new->next = h
c 语言单向链表的删除
比雅尼·斯特劳斯特鲁普（Bjarne Stroustrup）曾说过：如果你没看过这些博客，那么你的编程不会拥有智慧，你的代码不可能附有灵魂。
08-30 1920
单链表删除
链表的动态创建总结
weixin_61701822的博客
11-02 312
链表的动态创建总结
Java描述数据结构学习之链表的增删改查详解
08-27
主要给大家介绍了关于Java描述数据结构学习之链表的增删改查的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
c++实现链表增删改查
07-17
c++实现链表增删改查
动态链表的增删查改 学习C语言
weixin_40933653的博客
12-05 1276
大家好~ 在学习C语言的过程中，动态链表的相关操作总是会把我弄得有点晕。思路是有的，但是写完代码之后就很容易被自己绕晕。 于是今天想把我在链表的创建、输出、插入删除的过程中出现的问题总结一下，理清一下自己的思路，防止以后再犯同样的错。 链表是线性表的一种，所谓的线性表包含顺序线性表和链表，顺序线性表是用数组实现的，在内存中有顺序排列，通过改变数组大小实现。而链表不是用顺序实现的，用指针实现，在内存中不连续。意思就是说，链表就是将一系列不连续的内存联系起来，将那种碎片内存进行合理的利用，解决空间的问题。
单链表的增删改查操作详解之C语言版
sunnyoldboy博客
10-22 2629
单链表在应用中经常用到增加新结点、删除结点、修改结点、查找结点等操作，本文针对上述基本操作做了简单汇总，并给出了详细的算法。
共用体
03-27 5874
有时需要使几种不同类型的变量存放到同一段内存单元中。例如可以一个整形变量，一个字符型变量，一个实型变量放在同一地址开始的内存单元中。以上3个变量在内存单元中占的字节数不同，但是都从同一地址开始存放。也就是使用覆盖技术，几个变量互相覆盖。 共用体也是一种构造数据类型，它是将不同类型的变量存放在同一内存区域内。共用体也称为联合（union）。共用体的类型定义、变量定义及引用方式与
C语言-链表(操作：增、删、改、查)
qq_27751235的博客
07-19 833
链表是一种物理存储上非连续，数据元素的逻辑顺序通过链表中的指针链接次序，实现的一种线性存储结构。链表的操作：增、删、改、查。
C语言-链表-删除
m0_55823320的博客
05-10 544
删除的原理：改变指向地址。
c语言 数据结构--链表（1）
m0_52352637的博客
04-17 466
NULL && k<i-1) 不一样的原因是：假设当前表中有元素m个，插入一个元素就是m+1个 ，即可以在表的末尾插入元素。删除操作只能删除当前的m个元素。（1）段代码 i 表示为要插入的位置，它的合法取值范围是1<= i< =L->last+2，插入的位置可以是表的末尾，所以 L->last+1 可以再加1变成 L->last+2。（1）段代码 i 表示为要删除的位置，它的合法取值范围是1<= i< =L->last+1；假设线性表有（28，31，10，21，25，38），删除第四个元素，即。
C语言动态链表增删改查
06-01
好的，我可以为您介绍一下 C 语言中动态链表的增删改查操作。 首先，我们需要定义一个链表结构体： ```c typedef struct Node { int data; struct Node *next; } Node, *LinkedList; ``` 其中，`data` 表示链表节点中存储的数据，`next` 表示指向下一个节点的指针。 接下来，我们可以实现链表的创建操作： ```c LinkedList createList() { LinkedList head = (LinkedList)malloc(sizeof(Node)); head->next = NULL; return head; } ``` 这个函数会返回一个链表头节点的指针，也就是一个空链表。 接下来，我们可以实现链表节点的插入操作： ```c void insertNode(LinkedList L, int data) { Node *newNode = (Node *)malloc(sizeof(Node)); newNode->data = data; newNode->next = L->next; L->next = newNode; } ``` 这个函数会在链表头节点后插入一个新的节点。 接下来，我们可以实现链表节点的删除操作： ```c void deleteNode(LinkedList L, int data) { Node *p = L; while (p->next != NULL && p->next->data != data) { p = p->next; } if (p->next == NULL) { printf("Not found!\n"); return; } Node *tmp = p->next; p->next = tmp->next; free(tmp); } ``` 这个函数会在链表中查找指定数据的节点，并删除它。 最后，我们可以实现链表节点的查找操作： ```c Node *findNode(LinkedList L, int data) { Node *p = L->next; while (p != NULL && p->data != data) { p = p->next; } return p; } ``` 这个函数会在链表中查找指定数据的节点，并返回它的指针。 以上就是 C 语言中动态链表的增删改查操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 22
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

D.•

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值