数据结构——双链表

原创 已于 2025-11-21 20:10:14 修改 · 766 阅读 · 30 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #c语言 #算法

于 2025-11-21 20:09:05 首次发布

「C++ 40 周年」主题征文大赛（有机会与C++之父现场交流！） 10w+人浏览 460人参与

目录

一、链表的分类

二、双向链表的概念与结构

概念：

结构：

三、双向链表的代码实现

1.定义双向链表的结构

2.申请新节点

3.初始化

4.打印链表

5.尾插

6.头插

7.判断链表是否为空(是否只有一个哨兵位节点)

8.尾删

9.头删

10.查找值为pos的数据

11.在pos位置之后插入数据

12.删除pos位置的数据

13.销毁链表

四、完整代码分享

List.h

List.c

test.c

五、博主手记

前言：

前两篇文章我们介绍了单链表，这篇文章来介绍一下双链表（带头双向循环链表），再分享双链表的知识和代码实现之前，我们来简单介绍一下链表的分类，那么就让我们开启今天这篇文章吧！

一、链表的分类

链表的分类有：

带头与不带头、单向与双向、循环与不循环。

因此，链表的种类就有8种。

但是我们最常用的只有两种：不带头单向不循环链表和带头双向循环链表，也就是我们这两篇文章所说的单链表和双链表。

二、双向链表的概念与结构

概念：

双向链表就是带头双向循环链表，如图所示。

结构：

和单链表一样，物理结构：连续；  逻辑结构：不一定连续。

三、双向链表的代码实现

1.定义双向链表的结构

双向链表中有三个结构：data、*next、*prev

data ：保存有效数据

struct ListNode* next ：指针保存下⼀个结点的地址

struct ListNode* prev ：指针保存前⼀个结点的地址

typedef int LTDataType;
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* next;
	struct ListNode* prev;
}ListNode;

2.申请新节点

//申请新节点
ListNode* LTBuyNode(LTDataType x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)
	{
		perror("malloc");
		exit(1);
	}
	newnode->data = x;
	newnode->next = newnode;
	newnode->prev = newnode;
	return newnode;
}

3.初始化

初始化就是把头节点设置为存储无效数据，以便后面“放哨”用。

//初始化
ListNode* LTInit()
{
    ListNode* phead = LTBuyNode(-1);
	return phead;
}

4.打印链表

//打印链表
void LTPrint(ListNode* phead)
{
	assert(phead);
	ListNode* pcur = phead->next;
	while (pcur != phead)
	{
		printf("%d -> ", pcur->data);
		pcur = pcur->next;
	}
	printf("\n");
}

5.尾插

//尾插
void LTPushBack(ListNode* phead, LTDataType x)
{
	ListNode* newnode = LTBuyNode(x);
	newnode->next = phead;
	newnode->prev = phead->prev;
	phead->prev->next = newnode;
	phead->prev = newnode;
}

6.头插

//头插
void LTPushFront(ListNode* phead, LTDataType x)
{
	ListNode* newnode = LTBuyNode(x);
	newnode->next = phead->next;
	newnode->prev = phead;
	phead->next->prev = newnode;
	phead->next = newnode;
}

7.判断链表是否为空(是否只有一个哨兵位节点)

//判断链表是否为空(是否只有一个哨兵位节点)
bool LTEmpty(ListNode* phead)
{
	assert(phead);
	return phead->next == phead;
}

8.尾删

删除操作之前需要判断链表内是否为空，否则无法进行删除。

//尾删
void LTDelBack(ListNode* phead)
{
	assert(!LTEmpty(phead));
	ListNode* del = phead->prev;
	del->prev->next = phead;
	phead->prev = del->prev;
	free(del);
	del = NULL;
}

9.头删

//头删
void LTDelFront(ListNode* phead)
{
	assert(!LTEmpty(phead));
	ListNode* del = phead->next;
	del->next->prev = phead;
	phead->next = del->next;
	free(del);
	del = NULL;
}

10.查找值为pos的数据

//查找数据
ListNode* LTFind(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* pcur = phead->next;
	while (pcur != phead)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

11.在pos位置之后插入数据

//在pos之后插入节点
void LTInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* newnode = LTBuyNode(x);
	newnode->next = pos->next;
	newnode->prev = pos;
	pos->next->prev = newnode;
	pos->next = newnode;
}

12.删除pos位置的数据

//删除pos节点
void LTErase(ListNode* pos)
{
	assert(pos);
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;
	free(pos);
	pos = NULL;
}

13.销毁链表

//销毁链表
void LTDestory(ListNode* phead)
{
	ListNode* pcur = phead->next;
	while (pcur != phead)
	{
		ListNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	free(phead);
	phead = NULL;
}

进行完销毁链表函数之后，虽然已经将链表内的数据都释放掉了，但还需要将链表的头节点置为NULL，防止后面成为野指针被使用。

四、完整代码分享

List.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

typedef int LTDataType;
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* next;
	struct ListNode* prev;
}ListNode;

//初始化
ListNode* LTInit();
//申请新节点
ListNode* LTBuyNode(LTDataType x);
//打印链表
void LTPrint(ListNode* phead);
//判断链表是否为空(是否只有一个哨兵位节点)
bool LTEmpty(ListNode* phead);
//尾插
void LTPushBack(ListNode* phead, LTDataType x);
//头插
void LTPushFront(ListNode* phead, LTDataType x);
//尾删
void LTDelBack(ListNode* phead);
//头删
void LTDelFront(ListNode* phead);
//查找数据
ListNode* LTFind(ListNode* phead, LTDataType x);
//在pos之后插入节点
void LTInsert(ListNode* pos, LTDataType x);
//删除pos节点
void LTErase(ListNode* pos);
//销毁链表
void LTDestory(ListNode* phead);

List.c

#include"List.h"

//申请新节点
ListNode* LTBuyNode(LTDataType x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)
	{
		perror("malloc");
		exit(1);
	}
	newnode->data = x;
	newnode->next = newnode;
	newnode->prev = newnode;
	return newnode;
}

//初始化
ListNode* LTInit()
{
	ListNode* phead = LTBuyNode(-1);
	return phead;
}

//销毁链表
void LTDestory(ListNode* phead)
{
	ListNode* pcur = phead->next;
	while (pcur != phead)
	{
		ListNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	free(phead);
	phead = NULL;
}

//打印链表
void LTPrint(ListNode* phead)
{
	assert(phead);
	ListNode* pcur = phead->next;
	while (pcur != phead)
	{
		printf("%d -> ", pcur->data);
		pcur = pcur->next;
	}
	printf("\n");
}

//尾插
void LTPushBack(ListNode* phead, LTDataType x)
{
	ListNode* newnode = LTBuyNode(x);
	newnode->next = phead;
	newnode->prev = phead->prev;
	phead->prev->next = newnode;
	phead->prev = newnode;
}

//头插
void LTPushFront(ListNode* phead, LTDataType x)
{
	ListNode* newnode = LTBuyNode(x);
	newnode->next = phead->next;
	newnode->prev = phead;
	phead->next->prev = newnode;
	phead->next = newnode;
}

//判断链表是否为空(是否只有一个哨兵位节点)
bool LTEmpty(ListNode* phead)
{
	assert(phead);
	return phead->next == phead;
}
//尾删
void LTDelBack(ListNode* phead)
{
	assert(!LTEmpty(phead));
	ListNode* del = phead->prev;
	del->prev->next = phead;
	phead->prev = del->prev;
	free(del);
	del = NULL;
}

//头删
void LTDelFront(ListNode* phead)
{
	assert(!LTEmpty(phead));
	ListNode* del = phead->next;
	del->next->prev = phead;
	phead->next = del->next;
	free(del);
	del = NULL;
}

//查找数据
ListNode* LTFind(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* pcur = phead->next;
	while (pcur != phead)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

//在pos之后插入节点
void LTInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* newnode = LTBuyNode(x);
	newnode->next = pos->next;
	newnode->prev = pos;
	pos->next->prev = newnode;
	pos->next = newnode;
}

//删除pos节点
void LTErase(ListNode* pos)
{
	assert(pos);
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;
	free(pos);
	pos = NULL;
}

test.c

test,.c也就是测试函数，用来测试函数的功能。

#include"List.h"

void test1()
{
	 ListNode* plist=LTInit();
	 LTPushBack(plist, 1);
	 LTPushBack(plist, 2);
	 LTPushBack(plist, 3);
	 LTPushBack(plist, 4);
	 LTPrint(plist);

	 //LTPushFront(plist, 1);
	 //LTPrint(plist);
	 //LTPushFront(plist, 2);
	 //LTPrint(plist);
	 //LTPushFront(plist, 3);
	 //LTPrint(plist);
	 //LTPushFront(plist, 4);
	 //LTPrint(plist);

	 //LTDelBack(plist);
	 //LTPrint(plist);
	 //LTDelBack(plist);
	 //LTPrint(plist);
	 //LTDelBack(plist);
	 //LTPrint(plist);
	 //LTDelBack(plist);
	 //LTPrint(plist);
	 //LTDelBack(plist);
	 //LTPrint(plist);

	 //LTDelFront(plist);
	 //LTPrint(plist);
	 //LTDelFront(plist);
	 //LTPrint(plist);
	 //LTDelFront(plist);
	 //LTPrint(plist);
	 //LTDelFront(plist);
	 //LTPrint(plist);
	 //LTDelFront(plist);
	 //LTPrint(plist);

	 ListNode* pos = LTFind(plist, 3);
	 //if (pos != NULL)
	 //{
		// printf("找到了");
	 //}
	 //LTInsert(pos, 100);
	 //LTPrint(plist);
	 //
	 //LTErase(pos);
	 //LTPrint(plist);

	 LTDestory(plist);
	 plist = NULL;


}

int main()
{
	test1();
	return 0;
}

五、博主手记

这一部分是将博主记的笔记和解题思路分享给大家，大家可以参考一下思路。

结语：

双向链表对于单链表来说确实使用起来更加的方便，但是考虑到占用空间的问题，大家还是不能盲目的使用，还应该具体情况具体分析，来使用合适的结构完成。

redis的数据结构——双向链表
jkzyx123的博客
08-20 1135
Redis的双向链表数据结构详解
数据结构——双链表详解（超详细）
effort123_的博客
08-05 1470
哨兵位这个名字看起来是很威武的，其实了解它之后就知道它仅仅就是名字威武点，它才是真正意义上的头结点，哨兵位是不存数据的，它的存在仅仅就是为了说明这个链表是带头的，是用来“放哨的”，小编在讲述单链表的时候曾多次提到了头结点这个名字，那个时候头结点是链表第一个结点，这个叫法是不太规范的，不过为了让读者朋友更好的去理解链表的知识，小编于是就直接头结点来代替链表第一个结点了，不过各位读者朋友一定要清楚。下面紧跟小编的步伐，开启今天的双链表之旅！
数据结构——双向链表
麦麦的博客
03-11 2772
数据结构——双向链表：本文对双向链表的功能实现进行了详细地讲解，并与单链表的实现进行对比，干货满满，图文并茂，过万好文，不容错过！！！
数据结构——双链表的初始化及插入、删除
Prescu的博客
06-14 821
//双链表的相关操作 #include<stdio.h> #include<stdlib.h> typedef struct DNode{ int data; struct DNode *prior,*next; }DNode,*DLinklist; //初始化双链表 bool InitDLinklist(DLinklist &L){ L=(DNode *)malloc(sizeof(DNode)); if(L==NULL){ return false; } L->pr
数据结构——双向链表PTA习题
流楚丶格念的博客
12-17 6145
文章目录单选题函数题6-1 链式表操作集 (20分)各个操作函数的定义为：输入样例：输出样例：代码6-2 带头结点的链式表操作集 (20分)输入样例：输出样例：代码6-4 共享后缀的链表 (25分)输入样例：输出样例：代码 单选题 题号 题目 答案 1 设h为不带头结点的单向链表。在h的头上插入一个新结点t的语句是： t->next=h; h=t; 2 带头结点的单链表h为空的判定条件是： h->next == NULL; 3 对于一非空的循环单链表，h和p分别
python数据结构——双向链表
fyire的博客
08-17 666
1. 定义 每个节点有两个链接：一个指向前一个节点，当此节点为第一个节点时，指向空值；而另一个指向下一个节点，当此节点为最后一个节点时，指向空值。 2.
Rust 练习册 63：循环缓冲区与数据结构实现
少湖说
11-20 647
本文介绍了循环缓冲区（Circular Buffer）的实现方法，这是一种固定大小的先进先出数据结构。文章详细讲解了其核心特性：固定内存占用、O(1)时间复杂度的读写操作，以及避免频繁内存分配的优势。通过Rust代码示例展示了如何实现循环缓冲区的基本功能，包括初始化、写入、读取、清空和覆盖操作。实现使用了Vec<Option<T>>存储元素，并通过索引追踪读写位置，当缓冲区满时会覆盖最旧数据。该数据结构在需要高效内存管理和连续数据处理的场景中非常实用。
数据结构——五十二、散列函数的构造(王道408)
最新发布
2301_80201235的博客
11-23 598
本文总结了设计散列函数的注意事项和常用方法。设计散列函数时需注意：定义域覆盖所有关键字、值域不越界、减少冲突、计算简单。主要方法包括：除留余数法（取不大于表长的最大质数）、直接定址法（适用于连续关键字）、数字分析法（选取分布均匀的数码位）、平方取中法（取平方值的中间位）。其中重点阐述了除留余数法对质数取余可减少冲突的原因，并通过具体示例说明了各方法的适用场景和实现要点。这些方法可根据关键字特性选择使用，以达到均匀分布和高效存储的目的。
数据结构：栈详解-从原理到实现（顺序栈与链式栈）
2502_90793638的博客
11-19 959
顺序结构（基于数组）和链式结构（基于链表）。顺序栈结构简洁，易于理解，在内存分配固定且大小已知的情况下，具有高效的访问速度。然而，它也存在容量限制，需要预先定义MAXSIZE，容量不足时需要动态扩容，增加了实现的复杂度。链式栈则以其动态可变的特性而著称。它不受固定大小的限制，可以随着元素的增减自动调整，理论上可以存储无限个元素（受限于系统内存）。通过使用哨兵节点，我们进一步优化了链式栈的入栈和出栈操作，使其逻辑更加清晰，边界处理也更加优雅。选择哪种结构？
ts-属性修饰符，接口(约束数据结构)，抽象类(约束与复用逻辑)
岂不闻
11-23 608
类的基础知识，抽象类与接口(interface)对比，interface接口实现约束数据结构（组件通信传参，定义口返回数据结构），抽象类(约束数据结构以及复用逻辑)
【数据结构&C语言】排序大汇总
yuuki233233的博客
11-23 923
实现了常见的排序
【数据结构】扩展域并查集
2401_87820834的博客
11-19 836
扩展域并查集的应用
【数据结构与算法】数据结构_链表·栈·队列·哈希表·广义表·树·堆·并查集
Explorer Dong 的技术博客
11-19 977
本文介绍经典的数据结构与算法，包括：链表、栈、队列、哈希表、广义表、树、堆、并查集。
数据结构——五十一、散列表的基本概念(王道408)
2301_80201235的博客
11-23 550
本文介绍了散列表（哈希表）的基本概念和工作原理。散列表通过散列函数（如H(key)=key%13）将关键字映射到存储地址，实现快速查找（理想情况下时间复杂度O(1)）。文章重点讨论了冲突（不同关键字映射到同一地址）及其解决方法：拉链法（用链表存储同义词）和开放定址法（寻找其他空闲位置）。最后总结了散列表的核心考点，包括散列函数设计、冲突处理策略等。散列表作为一种高效的数据结构，在理想情况下能实现常数级查找性能，但需要合理处理冲突问题。
数据结构初阶：反射--＞Java实现
Qq121363Aa的博客
11-20 812
文章只讲述了反射私有属性与方法，但公有的也类似。反射不难，只是要用到许多方法。这也说明反射的效率不会很高，我们获取私有成员也不是那么容易的，private还是有一定的安全性。
2025-11-20[归并排序、快乐数]
2401_83386596的博客
11-20 695
摘要1：归并排序算法实现 该代码实现了归并排序算法，采用分治策略对整数数组进行升序排序。主函数MySort处理边界条件并初始化辅助数组，mergeSort函数递归地将数组分解为最小单元，merge函数合并有序子数组。算法时间复杂度稳定为O(nlogn)，空间复杂度O(n)，具有稳定性。通过辅助数组优化避免了频繁创建销毁，中点计算采用防溢出方式。可扩展为降序排序或支持其他数据类型。 摘要2：快乐数判断算法 该代码实现了快乐数判断功能，通过计算数字各位平方和迭代，检测是否能收敛到1。getSum函数计算平方和，
数据结构中的树【由浅入深-数据结构】
weixin_72937198的博客
11-20 947
本文介绍c语言实现数据结构中的树的相关内容。
【数据结构：从0到1】-14-直接寻址与哈希函数
技术探索者之路 - 一个专注于软件开发技术的实践型博客，涵盖移动应用开发、后端架构、Python编程和算法数据结构等核心技术领域。欢迎各位道友光临，喜欢本博主的别忘了一键三连哦。
11-20 49
哈希表是一种高效的数据结构，通过键值对存储数据，利用哈希函数实现快速访问。其核心思想是将键映射到数组特定位置，通过哈希函数和冲突解决策略（如链地址法）来处理键冲突。
学生成绩管理系统——基于链表数据结构的实现
链表是一种常见的基础数据结构，它由一系列节点组成，每个节点包含数据域和指向下一个节点的指针。链表可以有效地实现动态数据存储，不需要像数组一样在初始化时就确定大小，且插入和删除操作比数组更加高效，因为不...
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值