链表的概念

最新推荐文章于 2024-11-13 16:35:03 发布
最新推荐文章于 2024-11-13 16:35:03 发布
阅读量101 收藏
点赞数
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lvenshh/article/details/132223118
版权

概述：
链表作为 C 语言中一种基础的数据结构，在平时写程序的时候用的并不多，但在操作系统里面使用的非常多。不管是RTOS还是Linux等使用非常广泛，所以必须要搞懂链表，链表分为单向链表和双向链表，单向链表很少用，使用最多的还是双向链表。单向链表懂了双向链表自然就会了。

文章目录

一、链表的概念

链表的构成：

链表的操作:

双向链表

链表与数组的对比

二、链表的创建

三、链表的遍历

四、链表的释放

五、链表节点的查找

六、链表节点的删除

七、链表中插入一个节点

八、链表排序

九、双向链表的创建和遍历

十、双向链表插入节点

一、链表的概念
定义：

  链表是一种物理存储上非连续，数据元素的逻辑顺序通过链表中的指针链接次序，实现的一种线性存储结构。

特点：

  链表由一系列节点（链表中每一个元素称为节点）组成，节点在运行时动态生成 （malloc），每个节点包括两个部分：

 一个是存储数据元素的数据域

 另一个是存储下一个节点地址的指针域

图1 单向链表

链表的构成：
链表由一个个节点构成，每个节点一般采用结构体的形式组织，例如：

typedef struct student｛
int num；
char name[20]；
struct student *next；
}STU;
链表节点分为两个域

  数据域：存放各种实际的数据，如：num、score等

  指针域：存放下一节点的首地址，如：next等.

图2 节点内嵌在一个数据结构中

链表的操作:
链表最大的作用是通过节点把离散的数据链接在一起，组成一个表，这大概就是链表 的字面解释了吧。 链表常规的操作就是节点的插入和删除，为了顺利的插入，通常一条链 表我们会人为地规定一个根节点，这个根节点称为生产者。通常根节点还会有一个节点计 数器，用于统计整条链表的节点个数，具体见图3中的 root_node。

图3带根节点的链表

双向链表
双向链表与单向链表的区别就是节点中有两个节点指针，分别指向前后两个节点，其 它完全一样。有关双向链表的文字描述参考单向链表小节即可，有关双向链表的示意图具体见图4

图4双向链表

链表与数组的对比
在很多公司的嵌入式面试中，通常会问到链表和数组的区别。在 C 语言中，链表与数 组确实很像，两者的示意图具体见图5，这里以双向链表为例。

图5 链表与数组的对比

  链表是通过节点把离散的数据链接成一个表，通过对节点的插入和删除操作从而实现 对数据的存取。而数组是通过开辟一段连续的内存来存储数据，这是数组和链表最大的区 别。数组的每个成员对应链表的节点，成员和节点的数据类型可以是标准的 C 类型或者是 用户自定义的结构体。数组有起始地址和结束地址，而链表是一个圈，没有头和尾之分， 但是为了方便节点的插入和删除操作会人为的规定一个根节点。

二、链表的创建
第一步：创建一个节点

第二步：创建第二个节点，将其放在第一个节点的后面（第一的节点的指针域保存第二个节点的地址）

第三步：再次创建节点，找到原本链表中的最后一个节点，接着讲最后一个节点的指针域保存新节点的地址，以此内推。

#include <stdio.h>
#include <stdlib.h>
//定义结点结构体
typedef struct student
{
//数据域
int num; //学号
int score; //分数
char name[20]; //姓名
//指针域
struct student *next;
}STU;

void link_creat_head(STU **p_head,STU *p_new)
{
STU *p_mov = *p_head;
if(*p_head == NULL) //当第一次加入链表为空时，head执行p_new
{
*p_head = p_new;
p_new->next=NULL;
}
else //第二次及以后加入链表
{
while(p_mov->next!=NULL)
{
p_mov=p_mov->next; //找到原有链表的最后一个节点
}

    p_mov->next = p_new;	//将新申请的节点加入链表
    p_new->next = NULL;
}

}

int main()
{
STU *head = NULL,p_new = NULL;
int num,i;
printf(“请输入链表初始个数:\n”);
scanf(“%d”,&num);
for(i = 0; i < num;i++)
{
p_new = (STU)malloc(sizeof(STU));//申请一个新节点
printf(“请输入学号、分数、名字:\n”); //给新节点赋值
scanf(“%d %d %s”,&p_new->num,&p_new->score,p_new->name);

    link_creat_head(&head,p_new);	//将新节点加入链表
}

}

三、链表的遍历
第一步：输出第一个节点的数据域，输出完毕后，让指针保存后一个节点的地址

第二步：输出移动地址对应的节点的数据域，输出完毕后，指针继续后移

第三步：以此类推，直到节点的指针域为NULL

//链表的遍历
void link_print(STU *head)
{
STU *p_mov;
//定义新的指针保存链表的首地址，防止使用head改变原本链表
p_mov = head;
//当指针保存最后一个结点的指针域为NULL时，循环结束
while(p_mov!=NULL)
{
//先打印当前指针保存结点的指针域
printf(“num=%d score=%d name:%s\n”,p_mov->num,
p_mov->score,p_mov->name);

    //指针后移，保存下一个结点的地址
    p_mov = p_mov->next;
}

}

四、链表的释放
重新定义一个指针q，保存p指向节点的地址，然后p后移保存下一个节点的地址，然后释放q对应的节点，以此类推，直到p为NULL为止

//链表的释放
void link_free(STU **p_head)
{
//定义一个指针变量保存头结点的地址
STU *pb=*p_head;

while(*p_head!=NULL)
{
//先保存p_head指向的结点的地址
pb=*p_head;
//p_head保存下一个结点地址
*p_head=(*p_head)‐>next;
//释放结点并防止野指针
free(pb);
pb = NULL;
}
}

五、链表节点的查找
先对比第一个结点的数据域是否是想要的数据，如果是就直接返回，如果不是则继续查找下 一个结点，如果到达最后一个结点的时候都没有匹配的数据，说明要查找数据不存在

//链表的查找
//按照学号查找
STU * link_search_num(STU *head,int num)
{
STU *p_mov;
//定义的指针变量保存第一个结点的地址
p_mov=head;
//当没有到达最后一个结点的指针域时循环继续
while(p_mov!=NULL)
{
//如果找到是当前结点的数据，则返回当前结点的地址
if(p_mov->num == num)//找到了
{
return p_mov;
}
//如果没有找到，则继续对比下一个结点的指针域
p_mov=p_mov->next;
}

//当循环结束的时候还没有找到，说明要查找的数据不存在，返回NULL进行标识
return NULL;//没有找到

}

//按照姓名查找
STU * link_search_name(STU *head,char *name)
{
STU *p_mov;
p_mov=head;
while(p_mov!=NULL)
{
if(strcmp(p_mov->name,name)==0)//找到了
{
return p_mov;
}
p_mov=p_mov->next;
}
return NULL;//没有找到
}

六、链表节点的删除
如果链表为空，不需要删除 如果删除的是第一个结点，则需要将保存链表首地址的指针保存第一个结点的下一个结点的 地址 如果删除的是中间结点，则找到中间结点的前一个结点，让前一个结点的指针域保存这个结 点的后一个结点的地址即可

//链表结点的删除
void link_delete_num(STU **p_head,int num)
{
STU *pb,*pf;
pb=pf=*p_head;
if(*p_head == NULL)//链表为空，不用删
{
printf(“链表为空，没有您要删的节点”);
return ;
}
while(pb->num != num && pb->next !=NULL)//循环找，要删除的节点
{
pf=pb;
pb=pb->next;
}
if(pb->num == num)//找到了一个节点的num和num相同
{
if(pb == *p_head)//要删除的节点是头节点
{
//让保存头结点的指针保存后一个结点的地址
*p_head = pb->next;
}
else
{
//前一个结点的指针域保存要删除的后一个结点的地址
pf->next = pb->next;
}

    //释放空间
    free(pb);
    pb = NULL;
}
else//没有找到
{
    printf("没有您要删除的节点\n");
}

}

七、链表中插入一个节点
链表中插入一个结点，按照原本链表的顺序插入，找到合适的位置

情况（按照从小到大）：

  如果链表没有结点，则新插入的就是第一个结点。

  如果新插入的结点的数值最小，则作为头结点。

  如果新插入的结点的数值在中间位置，则找到前一个，然后插入到他们中间。

  如果新插入的结点的数值最大，则插入到最后。

//链表的插入：按照学号的顺序插入
void link_insert_num(STU **p_head,STU *p_new)
{
STU *pb,*pf;
pb=pf=*p_head;
if(*p_head ==NULL)// 链表为空链表
{
*p_head = p_new;
p_new->next=NULL;
return ;
}
while((p_new->num >= pb->num) && (pb->next !=NULL) )
{
pf=pb;
pb=pb->next;
}

if(p_new->num < pb->num)//找到一个节点的num比新来的节点num大，插在pb的前面
{
    if(pb== *p_head)//找到的节点是头节点，插在最前面
    {
        p_new->next= *p_head;
        *p_head =p_new;
    }
    else
    {
        pf->next=p_new;
        p_new->next = pb;
    }
}
else//没有找到pb的num比p_new->num大的节点，插在最后
{
    pb->next =p_new;
    p_new->next =NULL;
}

}

八、链表排序
如果链表为空，不需要排序。

  如果链表只有一个结点，不需要排序。

  先将第一个结点与后面所有的结点依次对比数据域，只要有比第一个结点数据域小的，则交 换位置。

   交换之后，拿新的第一个结点的数据域与下一个结点再次对比，如果比他小，再次交换，依 次类推。

  第一个结点确定完毕之后，接下来再将第二个结点与后面所有的结点对比，直到最后一个结 点也对比完毕为止。

//链表的排序
void link_order(STU *head)
{
STU *pb,*pf,temp;
pf=head;

if(head==NULL)
{
    printf("链表为空,不用排序\n");
    return ;
}

if(head->next ==NULL)
{
    printf("只有一个节点，不用排序\n");
    return ;
}

while(pf->next !=NULL)//以pf指向的节点为基准节点，
{
    pb=pf->next;//pb从基准元素的下个元素开始
    while(pb!=NULL)
    {
        if(pf->num > pb->num)
        {
            temp=*pb;
            *pb=*pf;
            *pf=temp;

            temp.next=pb->next;
            pb->next=pf->next;
            pf->next=temp.next;
        }
        pb=pb->next;
    }
    pf=pf->next;
}

}

九、双向链表的创建和遍历
第一步：创建一个节点作为头节点，将两个指针域都保存NULL

第二步：先找到链表中的最后一个节点，然后让最后一个节点的指针域保存新插入节点的地址，新插入节点的两个指针域，一个保存上一个节点的地址，一个保存NULL

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

//定义结点结构体
typedef struct student
{
//数据域
int num; //学号
int score; //分数
char name[20]; //姓名

//指针域
struct student *front;  //保存上一个结点的地址
struct student *next;   //保存下一个结点的地址

}STU;

void double_link_creat_head(STU **p_head,STU *p_new)
{
STU *p_mov=*p_head;
if(*p_head==NULL) //当第一次加入链表为空时，head执行p_new
{
*p_head = p_new;
p_new->front = NULL;
p_new->next = NULL;
}
else //第二次及以后加入链表
{
while(p_mov->next!=NULL)
{
p_mov=p_mov->next; //找到原有链表的最后一个节点
}
p_mov->next = p_new; //将新申请的节点加入链表
p_new->front = p_mov;
p_new->next = NULL;
}
}

void double_link_print(STU *head)
{
STU *pb;
pb=head;
while(pb->next!=NULL)
{
printf(“num=%d score=%d name:%s\n”,pb->num,pb->score,pb->name);
pb=pb->next;
}
printf(“num=%d score=%d name:%s\n”,pb->num,pb->score,pb->name);

printf("***********************\n");

while(pb!=NULL)
{
    printf("num=%d score=%d name:%s\n",pb->num,pb->score,pb->name);
    pb=pb->front;
}

}

int main()
{
STU *head=NULL,p_new=NULL;
int num,i;
printf(“请输入链表初始个数:\n”);
scanf(“%d”,&num);
for(i=0;i<num;i++)
{
p_new=(STU)malloc(sizeof(STU));//申请一个新节点
printf(“请输入学号、分数、名字:\n”); //给新节点赋值
scanf(“%d %d %s”,&p_new->num,&p_new->score,p_new->name);
double_link_creat_head(&head,p_new); //将新节点加入链表
}

double_link_print(head);

}

十、双向链表插入节点
按照顺序插入结点

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

//定义结点结构体
typedef struct student
{
//数据域
int num; //学号
int score; //分数
char name[20]; //姓名

//指针域
struct student *front;  //保存上一个结点的地址
struct student *next;   //保存下一个结点的地址

}STU;

void double_link_creat_head(STU **p_head,STU *p_new)
{
STU *p_mov=*p_head;
if(*p_head==NULL) //当第一次加入链表为空时，head执行p_new
{
*p_head = p_new;
p_new->front = NULL;
p_new->next = NULL;
}
else //第二次及以后加入链表
{
while(p_mov->next!=NULL)
{
p_mov=p_mov->next; //找到原有链表的最后一个节点
}
p_mov->next = p_new; //将新申请的节点加入链表
p_new->front = p_mov;
p_new->next = NULL;
}
}

void double_link_print(STU *head)
{
STU *pb;
pb=head;
while(pb->next!=NULL)
{
printf(“num=%d score=%d name:%s\n”,pb->num,pb->score,pb->name);
pb=pb->next;
}
printf(“num=%d score=%d name:%s\n”,pb->num,pb->score,pb->name);

printf("***********************\n");

while(pb!=NULL)
{
    printf("num=%d score=%d name:%s\n",pb->num,pb->score,pb->name);
    pb=pb->front;
}

}

//双向链表的删除
void double_link_delete_num(STU **p_head,int num)
{
STU *pb,*pf;
pb=*p_head;
if(*p_headNULL)//链表为空，不需要删除
{
printf(“链表为空，没有您要删除的节点\n”);
return ;
}
while((pb->num != num) && (pb->next != NULL) )
{
pb=pb->next;
}
if(pb->num == num)//找到了一个节点的num和num相同，删除pb指向的节点
{
if(pb == *p_head)//找到的节点是头节点
{
if((*p_head)->nextNULL)//只有一个节点的情况
{
*p_head=pb->next;
}
else//有多个节点的情况
{
*p_head = pb->next;//main函数中的head指向下个节点
(*p_head)->front=NULL;
}
}
else//要删的节点是其他节点
{
if(pb->next!=NULL)//删除中间节点
{
pf=pb->front;//让pf指向找到的节点的前一个节点
pf->next=pb->next; //前一个结点的next保存后一个结点的地址
(pb->next)->front=pf; //后一个结点的front保存前一个结点的地址
}
else//删除尾节点
{
pf=pb->front;
pf->next=NULL;
}
}

    free(pb);//释放找到的节点

}
else//没找到
{
    printf("没有您要删除的节点\n");
}

}

int main()
{
STU *head=NULL,p_new=NULL;
int num,i;
printf(“请输入链表初始个数:\n”);
scanf(“%d”,&num);
for(i=0;i<num;i++)
{
p_new=(STU)malloc(sizeof(STU));//申请一个新节点
printf(“请输入学号、分数、名字:\n”); //给新节点赋值
scanf(“%d %d %s”,&p_new->num,&p_new->score,p_new->name);
double_link_creat_head(&head,p_new); //将新节点加入链表
}

double_link_print(head);

printf("请输入您要删除的节点的num\n");
scanf("%d",&num);
double_link_delete_num(&head,num);
double_link_print(head);

}
————————————————
版权声明：本文为CSDN博主「不秃也很强」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_61672347/article/details/125701955

lvencsdn
关注
什么是链表
kokopop007的博客
08-26 2500
链表 为什么需要链表 顺序表的构建需要预先知道数据大小来申请连续的存储空间，而在进行扩充时又需要进行数据的搬迁，所以使用起来并不是很灵活。 链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。 链表的定义 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是不像顺序表一样连续存储数据，而是在每一个节点（数据存储单元）里存放下一个节点的位置信息（即地址）。 链表的表...
C++基础语法：链表
baiyechangjiu的博客
08-19 8140
链表是物理存储单元上非连续的，非顺序的存储结构，链表是由一个个结点，通过指针来联系起来的，其中每个结点包含数据和指针： 或者我们采用另一张更加明显的图： 因为在C++语言中，当我们生成一个数组的时候，就要声明数组的长度，如此计算机便会在内存上开辟一个连续的不间断的内存空间来存储数据，因为存在着这样的一种可能，也就是数组所使用的内存空间之后的内存空间已经被使用，所以C++中一旦数组的大小明确了，就不能够再改变了。而且因为数组是存储一系列的同一类型的变量的集合，所以构成数组的每一个元素占用的内.
c语言链表
qq_25205059的博客
04-12 143
#include <stdio.h> #include <stdlib.h> typedef struct Student // 取别名 { int num;// 学号 char name;// 姓名 // 指针 struct Student *pnext;// 这个指针指向下一个节点 /*两种链表 1.不带头结点的链表 ...
链表概念学习
weixin_46413941的博客
11-16 356
链表概念学习
数据结构 09-链表概念及常见链表结构
一分耕耘一分收获
06-07 933
链表概念 前面提到，栈、队列都可以视作是一种特殊的线性表，在绝大多数语言中都是连续存储的。而链表则是不连续的存储方式，自适应内存大小，通过指针的使用，灵活将不同的内存块联系起来，实现动态增加动态删除。 链表的基础是结点 node，每个结点应该包含至少两个区域，一个是存放数据的区域，一个是指向下一个节点的指针。对于整个链表而言，应该有指向头结点的头指针，尾部结点根据链表的不同类型可以指向空（单链表），也可以指向头节点（循环链表）。根据指针的配置，结点可以是单向的，也可以是双向...
数据结构与算法（五）--链表概念以及向链表添加元素
学习不止境的博客
09-20 1444
今天我们学习另一种非常重要的线性数据结构–链表，之前我们已经学习了三种线性数据结构，分别是动态数组，栈和队列。其中队列我们额外学习了队列的另一种实现方式–循环队列。其实我们自己实现过前三个数据结构就知道，它们底层均依托静态数组，靠resize解决固定容量问题。而链表和前三种均不同，它是真正的动态数据结构。 学好链表，有利于： 就像火车一样，每一个节点就像一个个车厢，车厢除了人(数据)，还要和其他车厢进行连接，以使得数据是整合在一起的，用户可以方便的在所有的数据上进行查询等其他操作。而数据和数据之间的连接就是
顺序表补充和链表概念
Xguoqing的博客
03-16 75
顺序表补充和链表概念
链表的概念、链表的优势、链表的c语言和java语言的实现
01-10
链表是一种重要的数据结构，它在计算机科学中扮演着至关重要的角色。与数组或集合等其他数据结构不同，链表不依赖于物理位置的连续性来存储数据。链表的每个元素，即结点，包含两个部分：一个是存储数据的部分，另一...
介绍链表相关概念以及使用示例
03-13
介绍链表以及使用示例。链表是一种线性数据结构，由一系列节点组成，每个节点包含数据域和指向下一个节点的指针域。这种结构允许动态地插入和删除元素，因为每个节点独立管理其后继节点的引用。链表可以是单向的，即...
二叉链表的应用c++代码_二叉链表c++代码_
09-30
通过阅读并理解这段代码，你可以进一步巩固对二叉链表概念和C++编程的理解，并能将其应用于实际项目中。 总的来说，二叉链表是数据结构学习的重要部分，熟练掌握其原理和实现方法对于提升编程能力大有裨益。通过...
二叉树遍历/算法&数据结构
2403_86942375的博客
11-10 874
其实很简单，根据遍历的顺序摆放遍历顺序和添加元素的顺序，(root.left, result)代表左子树，(root.right, result)代表右子树，(root.val)代表中节点。其实很简单，参数就是要目前遍历节点在哪，返回值也同理，终止条件就是指遍历到null的时候回溯，逻辑不要想复杂，根据顺序移动上述上个递归函数即可。前序（要理解遍历的核心，先把中节点塞入，然后根据栈去模拟，先加入右节点然后是左节点，移动到左节点继续加入）后序（就是前序遍历的左右调换顺序，然后再倒叙结果数组）
如何实现一个既保证顺序又有快速插入删除的数据结构？
weixin_44617651的博客
11-13 526
当我们要实现一个既保证顺序又支持快速插入和删除的自定义数据结构，可以考虑使用 双向链表 或 跳表，甚至是结合 字典 和 链表 的方法，这些数据结构在不同需求场景下能够提供优化的性能。
华为OD机试真题---数组二叉树
风信子的博客
11-13 799
二叉树只也可以用数组来存储，给定一个数组，树的根节点的值储存在下标1，对于储存在下标n的节点，他的左子节点和右子节点分别储存在下标2n和2n+1，并且我们用-1代表一个节点为空，给定一个数组存储的二叉树，试求从根节点到最小的 叶子节点只的路径，路径由节点的值组成。
C 语言 数组交换最小值和最大值
kukubuzai的博客
11-11 191
本题要求编写程序，先将输入的一系列整数中的最小值与第一个数交换，然后将最大值与最后一个数交换，最后输出交换后的序列。注意：题目保证最大和最小值都是唯一的。
数据结构大致分类
weixin_44512485的博客
11-13 402
表、树、图和集合是数据结构的四大基石，每种结构都有特定的应用场景和优势。在实际应用中，选择合适的数据结构对算法的效率和程序的性能至关重要。
二叉树-堆
2301_81256732的博客
11-09 1224
二叉树-堆
【数据结构】10.线索二叉树
caryon的博客
11-13 472
介绍了线索二叉树的背景与实现
数据结构-树
wwwwwgery的博客
11-13 244
【代码】数据结构-树。
【数据结构】11.哈夫曼树&&哈夫曼编码
最新发布
caryon的博客
11-13 570
详细的介绍了哈夫曼树的创建与哈夫曼编码的实现
数据结构：顺序表（动态顺序表）
小黄鸭的博客
11-09 721
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存。动态顺序表：使用动态开辟的数组存储。静态顺序表：使用定长数组存储元素。在数组上完成数据的增删查改。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值