链表基础知识详解（非常详细简单易懂）

最新推荐文章于 2024-06-26 00:36:55 发布
最新推荐文章于 2024-06-26 00:36:55 发布
阅读量510 收藏 6
点赞数
分类专栏： 编程与数据结构 文章标签： 链表 数据结构
原文链接：https://blog.csdn.net/qq_61672347/article/details/125701955?spm=1001.2014.3001.5506
版权

文章目录

概述

链表作为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);//将新节点加入链表
	}
	return 0;
}

三、链表的遍历

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

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

第三步：以此类推，直到节点的指针域为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){//找到了
			returnp_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;
	}
	//如果循环结束时还没有找到，说明要查找的数据不存在，返回NULL进行标识
	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=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=%dscore=%dname:%s\n",pb->num,pb->score,pb->name);
		pb=pb->front;
	}
}

//主函数
int main(){
	STU *head=NULL,*p_new=NULL;
	intnum,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);
	return0;
}

十、双向链表插入节点

按照顺序插入结点

#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=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=%dscore=%dname:%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_head == NULL){//链表为空，不需要删除
		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)->next == NULL){//只有一个节点的情况
				*p_head=pb->next;
			}else{//有多个节点的情况
				*p_head=pb->next;
				(*p_head)->front=NULL;
			}
		}else{//要删的节点是其他节点
			if(pb->next != NULL){//删除中间节点
				pf=pb->front;
				pf->next=pb->next;
				(pb->next)->front=pf;
			}else{//删除尾节点
				pf=pb->front;
				pf->next=NULL;
			}
		}
		free(pb);//释放找到的节点
	}else{//没找到
		printf("没有您要删除的节点\n");
	}
}

int main(){
	STU *head=NULL,*p_new=NULL;
	intnum,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);

	return0;
}

本文转自https://blog.csdn.net/qq_61672347/article/details/125701955，如有侵权，请联系删除。

钢琴上的汽车软件
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之链表基础知识点
StormFang的博客
01-24 955
链表：链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。相比于线性表顺序结构，链表比较方便插入和删除操作。 定义typedef int ElemType; typedef str
简单易懂的指针教程
10-15
### 指针基础知识 #### 一、引言 在计算机编程中，指针是一种非常重要的数据类型，尤其是在C和C++这样的低级语言中。指针能够直接操作内存地址，使得程序运行更加高效，同时也增加了程序的灵活性。本文旨在为初学...
数据结构之链表 - 超详细的教程，手把手教你认识并运用链表
ミカミミミ博客
09-03 3235
数据结构之链表 - 超详细的教程，手把手教你认识并运用链表！
数据结构之”单链表“
最新发布
kk1kk2kk3kk4的博客
06-26 25
接下来介绍的是”单链表“，单链表只是简称，单链表是一个不带哨兵位单向不循环的链表。其次它可以不是连续储存的内存，它和我们生活中的火车很像。
链表基础知识
小菜鸡
03-08 679
链表 基础知识 关于链表，你该了解这些！ 什么是链表，链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。 链接的入口节点称为链表的头结点也就是head。 如图所示： 链表的类型 接下来说一下链表的几种类型: 单链表 刚刚说的就是单链表。 双链表 单链表中的节点只能指向节点的下一个节点。 双链表：每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。 双链表 既可以向前查询也可以向
链表的基础知识
Code_ZX的博客
04-20 1098
//链表基础知识typedef int DataType;typedef struct ListNode{ struct ListNode* _pNext; DataType _data;}ListNode,*PNode;// 链表的初始化 void SListInit(PNode* pHead);//创建新结点PNode BuyNewNode(DataType data);// 尾插 void ...
51单片机实现8X8点阵贪吃蛇程序代码通俗易懂按功能多文件编写
04-21
在压缩包中的"点阵屏坐标显示代码写贪吃蛇基础.rar"文件，包含了以上各部分的详细实现。"snake"文件可能是源代码的主文件，整合了所有功能模块。通过阅读和分析这些源代码，读者可以了解到51单片机如何与硬件交互，...
简单的通讯录程序 c++
07-04
在通讯录程序中，会涉及到变量声明、条件语句（如if-else）、循环结构（如for、while）以及函数的使用等基础知识。 2. **面向对象编程（OOP）**：C++支持OOP，程序可能包含了类（Class）的设计，如`Contact`类来...
【BAT必备】数据结构算法面试题
09-25
通过对上述数据结构与算法面试题的分析，我们可以看出，掌握扎实的数据结构与算法基础知识对于准备BAT等大厂的技术面试至关重要。此外，深入理解各种数据结构的特点和应用场景，灵活运用不同的算法解决问题，能够...
Fat文件系统原理2（通俗易懂Fat文件系统原理，适合初学者学习）
11-14
本文将通过通俗易懂的语言，详细阐述FAT文件系统的工作原理，尤其是FAT16和FAT32两种格式，帮助初学者理解这一基础知识。 ### FAT文件系统概述 FAT文件系统的核心在于FAT表，它是一种链表结构，用于追踪文件或目录...
一个简单的贪吃蛇游戏
02-26
通过这个简单的贪吃蛇游戏项目，开发者不仅可以巩固Java和Swing的基础知识，还能学习到游戏开发的基本原理和实践技巧，为将来更复杂的项目打下坚实基础。这个项目提供了一个良好的学习平台，对于初学者来说，是一个...
包含500道leetcode题，从简单到难的都有，提供代码实现
03-02
这些题目通常会涉及到基础的编程知识，如循环、条件语句、函数调用，以及更高级的编程技巧，如动态规划、回溯法、贪心策略等。 在提供的资源包中，`server.py`可能是一个用于模拟服务器环境或者处理数据提交的脚本...
Search_jsp.rar_Free!
09-23
首先，链表是一种非常基础且重要的数据结构，它在内存中不连续存储，通过节点之间的指针链接起来。在"Search_jsp"中，链表被用来存储图书信息，每个节点包含图书的ID、书名、作者、出版日期等元数据。这种结构允许...
python链表基础知识
10-22
Python中的链表是一种数据结构，它由一组节点组成，每个节点包含一个数据项和一个指向下一个节点的链接。链表有两种类型：单链表和双链表。在Python中，我们可以使用类来定义链表和节点。链表的基本操作包括增、删、改、查四种情况。其中，创建空链表时，只需要把相应的链表头节点变量设置为空链接即可。在Python里可以将其设置为None。求线性链表的长度可以通过遍历链表并计数来实现。在链表中删除操作可以通过修改节点的链接来实现。具体实现可以参考链表的结构定义和操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值