C语言：详解双向链表

最新推荐文章于 2025-08-03 13:05:02 发布
最新推荐文章于 2025-08-03 13:05:02 发布
阅读量1.2k 收藏 14
点赞数 30
CC 4.0 BY-SA版权
文章标签： c语言 链表 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2501_90377063/article/details/149814064

C语言：详解双向链表

1.双向链表的结构
2.双向链表的实现

1.双向链表的结构

双向链表是带头双向循环链表。

  • 链表带头的意思是有头节点，且头节点的数据是无效的。
  • 双向指两节点能通过指针互相访问，上一节点可通过next指针找到下一节点，下一节点可通过prev指针找到上一节点。
  • 循环指尾节点能通过next指针找到头节点，双向链表由于具有“双向”的性质，所以头节点能通过prev指针直接找到尾节点。

双向链表的节点由3个部分组成，分别是数据、指向下一节点的指针next、指向上一节点指针prev。

对于单链表，指向第一个节点的指针phead为NULL时，链表为空；对于双向链表，链表只有一个头节点时，为空链表，此时phead->next指向phead，phead->prev指向phead。
在这里插入图片描述

双向链表的结构如图所示：
在这里插入图片描述

2.双向链表的实现

创建3个文件，在头文件List.h中定义节点结构体、进行函数声明、包含所需头文件；在文件List.c中编写函数；最后在test.c中进行测试。

在List.h中，需声明的函数有初始化链表、销毁链表、打印链表、尾/头插、尾/头删、在pos指向的节点后插入、删除pos指向的节点、查找节点。

//List.h
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int LTDataType;
typedef struct ListNode    //定义双向链表节点结构
{
	LTDataType data;       //数据
	struct ListNode* next; //指向下一个节点的指针
	struct ListNode* prev; //指向上一个节点的指针
}LTNode;
LTNode* LTInit();  //初始化

void LTDesTroy(LTNode* phead);//销毁链表

void LTPrint(LTNode* phead);//打印

void LTPushBack(LTNode* phead, LTDataType x);//尾插

void LTPushFront(LTNode* phead, LTDataType x);//头插

void LTPopBack(LTNode* phead);//尾删

void LTPopFront(LTNode* phead);//头删

void LTInsert(LTNode* pos, LTDataType x);//在pos后插入

void LTErase(LTNode* pos);//删pos

LTNode* LTFind(LTNode* phead, LTDataType x);//查找
打印链表

遍历双向链表，即可完成打印。但需要注意，与单链表不同，双向链表的头节点的数据是无效的，所以要从第一个有效节点开始遍历，即指针pcur应赋为phead->next；在循环中用pcur=pcur->next使指针pcur移动，当pcur指向尾节点时，pcur->next又指向头节点，所以循环条件是pcur不能为phead。

void LTPrint(LTNode* phead)//打印
{
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("\n");
}
申请节点

用malloc函数动态开辟内存空间，定义指向新节点的指针node指向这块空间，赋给所需数据，让新节点的next、prev指针都指向自己，最后返回新节点。

LTNode* LTBuyNode(LTDataType x)//申请节点
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	node->data = x;
	node->next = node;
	node->prev = node;
	return node;
}
初始化

用LTBuyNode申请一个数据为-1的新节点，再定义一个指针phead指向这个节点，返回phead。使用时用LTNode类型指针接收phead。

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

先让新节点newnode连上头节点和尾节点，即newnode->prev=phead->prev，newnode->next=phead。
在这里插入图片描述
再让尾节点连上newnode，头节点连上newnode，即phead->prev->next=newnode，phead->prev=newnode，两步的先后顺序不可调换，因为执行完phead->prev->next=newnode后，尾节点就是newnode了，phead->prev原来指向d3节点，应改为指向newnode。
在这里插入图片描述

void LTPushBack(LTNode* phead, LTDataType x)//尾插
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);
	newnode->prev = phead->prev;//连上尾节点
	newnode->next = phead;      //连上头节点
	phead->prev->next = newnode;//尾节点连上newnode
	phead->prev = newnode;      //头节点连上newnode
}
头插

新节点应插在头节点和第一个有效节点之间，先让newnode连上头节点和第一个有效节点。
在这里插入图片描述
再让头节点连上newnode，第一个有效节点连上newnode。
在这里插入图片描述

void LTPushFront(LTNode* phead, LTDataType x)//头插
{                                            //插在头节点和第一个有效节点之间
	assert(phead);
	LTNode* newnode = LTBuyNode(x);
	newnode->prev = phead;      //连上头节点
	newnode->next = phead->next;//连上第一个有效节点
	phead->next->prev = newnode;//第一个有效节点连上newnode
	phead->next = newnode;      //头节点连上newnode    
}
尾删

删除尾节点前要保存尾节点，头节点连上尾节点的上一个节点，尾节点的上一个节点连上头节点。
在这里插入图片描述

void LTPopBack(LTNode* phead)//尾删
{
	assert(phead && phead->next != phead);//链表有效且不只有头节点
	LTNode* del = phead->prev;//保存尾节点
	del->prev->next = phead;  //尾节点的上一个节点连上头节点
	phead->prev = del->prev;  //头节点连上尾节点的上一个节点
	free(del);
	del = NULL;
}
头删

头删删的是第一个有效节点，先头节点连上第一个有效节点的下一节点，再第一个有效节点的下一节点连上头节点。
在这里插入图片描述

void LTPopFront(LTNode* phead)//头删
{                             //删第一个有效节点
	assert(phead && phead->next != phead);
	LTNode* del = phead->next;//保存第一个有效节点
	phead->next = del->next;  //头节点连上第一个有效节点的下一节点
	del->next->prev = phead;  //第一个有效节点的下一节点连上头节点
	free(del);
	del = NULL;
}
查找

从第一个有效节点开始遍历链表，若pcur->data==x，即找到了。

LTNode* LTFind(LTNode* phead,LTDataType x)//查找
{
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		if (pcur->data == x)
			return pcur; //找到了
		pcur = pcur->next;
	}
	return NULL; //没找到
}
在pos后插入数据

pos指向指定的节点，先让新节点newnode连上pos指向的节点，以及连上pos指向节点的下一节点。
在这里插入图片描述
接下来，先让pos->next指向节点连上新节点，再让pos连上新节点。
在这里插入图片描述

void LTInsert(LTNode* pos, LTDataType x)//在pos后插入数据
{
	assert(pos);
	LTNode* newnode = LTBuyNode(x);
	newnode->prev = pos;
	newnode->next = pos->next;
	pos->next->prev = newnode;
	pos->next = newnode;
}
删除pos

指向pos指向节点的上一节点的指针为pos->prev，指向pos指向节点的下一节点的指针为pos->next，在删除pos指向节点前把上下两节点连起来，用free释放掉pos，即可删除pos。
在这里插入图片描述

void LTErase(LTNode* pos)//删除pos
{
	assert(pos);
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;// pos->prev  pos  pos->next
	free(pos);
	pos = NULL;
}
销毁链表

遍历链表，循环一次销毁一个节点，遍历链表时应及时保存下一节点，避免销毁节点后找不到下一节点。

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

List.c文件中代码如下：

//List.c
#include"List.h"
void LTPrint(LTNode* phead)//打印
{
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("\n");
}
LTNode* LTBuyNode(LTDataType x)//申请节点
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	node->data = x;
	node->next = node;
	node->prev = node;
	return node;
}
LTNode* LTInit()//初始化
{
	LTNode* phead = LTBuyNode(-1);
	return phead;
}
void LTPushBack(LTNode* phead, LTDataType x)//尾插
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);
	newnode->prev = phead->prev;//连上尾节点
	newnode->next = phead;      //连上头节点
	phead->prev->next = newnode;//尾节点连上newnode
	phead->prev = newnode;      //头节点连上newnode
}
void LTPushFront(LTNode* phead, LTDataType x)//头插
{                                            //插在头节点和第一个有效节点之间
	assert(phead);
	LTNode* newnode = LTBuyNode(x);
	newnode->prev = phead;      //连上头节点
	newnode->next = phead->next;//连上第一个有效节点
	phead->next->prev = newnode;//第一个有效节点连上newnode
	phead->next = newnode;      //头节点连上newnode    
}
void LTPopBack(LTNode* phead)//尾删
{
	assert(phead && phead->next != phead);//链表有效且不只有头节点
	LTNode* del = phead->prev;//保存尾节点
	del->prev->next = phead;  //尾节点的上一个节点连上头节点
	phead->prev = del->prev;  //头节点连上尾节点的上一个节点
	free(del);
	del = NULL;
}
void LTPopFront(LTNode* phead)//头删
{                             //删第一个有效节点
	assert(phead && phead->next != phead);
	LTNode* del = phead->next;//保存第一个有效节点
	phead->next = del->next;  //头节点连上第一个有效节点的下一节点
	del->next->prev = phead;  //第一个有效节点的下一节点连上头节点
	free(del);
	del = NULL;
}
LTNode* LTFind(LTNode* phead,LTDataType x)//查找
{
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		if (pcur->data == x)
			return pcur; //找到了
		pcur = pcur->next;
	}
	return NULL; //没找到
}
void LTInsert(LTNode* pos, LTDataType x)//在pos后插入数据
{
	assert(pos);
	LTNode* newnode = LTBuyNode(x);
	newnode->prev = pos;
	newnode->next = pos->next;
	pos->next->prev = newnode;
	pos->next = newnode;
}
void LTErase(LTNode* pos)//删除pos
{
	assert(pos);
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;// pos->prev  pos  pos->next
	free(pos);
	pos = NULL;
}
void LTDesTroy(LTNode* phead)//销毁链表
{
	assert(phead);
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		LTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	free(phead);
	phead = NULL;
}
测试

在test.c文件中测试上述代码。

例如：创建节点的数据为1，2，4的双向链表。

//test.c
#include"List.h"
void test1()
{
	LTNode* phead = LTInit();
	LTPushBack(phead, 2);
	LTPushFront(phead, 1);
	LTPushBack(phead, 4);
	LTPrint(phead);
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述
在此基础上创建节点为1，2，3，4的链表。

//test.c
#include"List.h"
void test1()
{
	LTNode* phead = LTInit();
	LTPushBack(phead, 2);
	LTPushFront(phead, 1);
	LTPushBack(phead, 4);
	LTNode* ret1 = LTFind(phead, 2);
	LTInsert(ret1, 3);
	LTPrint(phead);
}
int main()
{
	test1();
	return 0;
}

在这里插入图片描述

拙作一篇，望诸位同道不吝斧正。

拳里剑气
关注
C语言-双向链表的详解和实现
qq_42037383的博客
06-25 531
/ 双向链表节点结构int data;// 节点数据域// 指向前一个节点的指针// 指向后一个节点的指针} Node;// 双向链表结构体定义Node* head;// 头结点指针，指向链表的头部int size;// 链表中节点的数量双向链表通过每个节点存储前驱和后继节点的指针，支持从任意位置直接访问前后节点，使得插入、删除等操作在某些场景下比单链表更加高效。
C语言详解双向链表的基本操作
qq_61386381的博客
05-17 3920
双链表的定义与接口函数 定义双链表 接口函数 详解接口函数的实现 创建新节点（BuyLTNode） 初始化双链表（ListInit） 双向链表打印（ListPrint） 双链表查找（ListFind） 双链表销毁（ListDestory） 1、双链表pos位置之前插入（ListInsert） 2、双链表删除pos位置（ListEarse） 3、双向链表尾插（ListPushBack） 4、双向链表头插（ListPushFront） 5、双链表头删（ListPopF.......
C语言链表超详解
热门推荐
k666499436的博客
05-17 14万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
【C语言】双向链表详解
2301_77954967的博客
04-12 1654
一篇博客带你理解双向链表的实现及注意事项
c语言链表超详解
cuitlse的博客
08-08 1038
链表是一种基本的数据结构，它由一系列节点组成，每个节点包含一个值和指向下一个节点的指针。链表的缺点是访问操作的时间复杂度为O(n)，而且需要额外的空间存储节点的指针，因此在需要频繁访问数据的场景中，效率可能不如数组。链表在计算机科学中有广泛的应用，例如操作系统中的进程链表、文件系统中的目录链表、图论中的邻接表等。双向链表的优点是可以实现双向遍历和O(1)的删除操作，缺点是每个节点需要额外的一个指针。循环链表：在单向或双向链表的基础上，将最后一个节点的指针指向头节点，形成一个环。
C语言链表详解
qq_28576837的博客
06-02 5216
C语言链表详解
[C语言数据结构]双向循环链表
本科在读，致力于Linux/C++方向的学习，同时涉及数据结构与算法，操作系统，数据库mysql等等
11-10 1992
上次我们学习了单链表的实现，相对于双向循环链表来说，单链表的各中操作，比如说增删查改等都显得非常麻烦。所以接下来来学习一下双向循环链表吧！
C语言链表详解（通俗易懂）
weixin_61661271的博客
06-05 5万+
线性表是实际中广泛应用的重要数据结构，本文用通俗易懂的方法讲解它。
C语言——详解带头双向循环链表 增删查改
qq_62476499的博客
01-08 902
详细讲解带头循环双向链表的增删查改等基本操作
C语言数据结构 双向链表的建立与基本操作
08-31
C语言数据结构 双向链表的建立与基本操作 C语言数据结构中，双向链表是一种常用的数据结构形式，它可以实现链表的前序和后序遍历，提高了链表的灵活性和可读性。本文将主要介绍双向链表的建立和基本操作，包括双向...
C语言之双向链表详解及实例代码
12-31
1，双向链表简介。 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般...
C语言实现详解：双向链表操作与应用
在C语言编程中，双向链表是一种常见的数据结构，它允许在任意位置高效地进行插入和删除操作。双向链表中的每个节点都包含三个部分：数据域和两个指针域，其中指针域分别指向前一个节点和后一个节点。与单向链表相比...
#C语言——学习攻略：深挖指针路线（四）--字符指针变量，数组指针变量，二维数组传参的本质，函数指针变量，函数指针数组
2501_91617454的博客
07-30 859
本文主要探讨了C语言中指针变量的不同类型及其使用方式。首先介绍了字符指针变量的三种使用方式，包括指向字符变量、字符数组和常量字符串的情况，并通过例题解释了不同存储方式导致的地址差异。其次讲解了数组指针变量的定义和初始化方法，强调其与指针数组的区别。在二维数组传参部分，分析了数组形式和指针形式的参数传递本质。文章还详细介绍了函数指针变量的创建和使用方式，并通过两个复杂代码示例展示了函数指针的高级应用。最后简要提及了typedef关键字对复杂类型的简化和函数指针数组的概念。全文通过丰富示例系统讲解了指针变量的各
创建两个 C 语言文件，实现使用共享内存和信号量集进行两个进程间的双向聊天功能。这两个文件分别为chat1.c和chat2.c，它们可以互相发送和接收消息。
2401_82762455的博客
07-30 237
chat1.c chat2.c 这个聊天程序使用了共享内存和信号量集实现两个进程间的双向通信：共享内存：信号量集：工作流程：编译两个文件： 运行时先启动 chat1，再在另一个终端启动 chat2： 这样两个进程就可以互相发送消息进行聊天了。
Rust：开发 DLL 动态链接库时如何处理 C 字符串
程序猿视角
08-03 562
本文详细介绍了Rust开发DLL时处理C字符串与Rust String相互转换的安全方法。主要内容包括：1）将C字符串(const c_char)安全转换为Rust String；2）将Rust String转换为C可用的mut c_char指针；3）完整DLL示例与C调用方式；4）高级技巧如错误处理、多字节编码转换和复杂数据结构返回。重点强调了内存安全、所有权管理和错误处理，提供了空指针检查、线程安全等最佳实践，并警告了常见陷阱。最后建议使用cbindgen自动生成头文件，确保跨语言调用的安全性。
C语言笔记4：错题整理
chen20100531的博客
08-01 198
1.2 从键盘输入10个数据，存入数组当中，程序实现，统计数组当中出现次数最多的数以及是哪一个数。(如果有次数相同则输出第一个出现数字).把字符串“123456”转换成数值123456 int atoi(char *str);4 写一个函数，统计一个int类型(32)的数中有多少位二进制数1？判断101-500之间有多少个素数，放入数组中，遍历数组输出所有素数，素数： 除了1和它本身以外不再有其他的因数。具体实现 就用DeepSeek了。请实现类似atoi函数，
开发语言的优劣势对比及主要应用领域分析
qq_39980997的博客
07-13 1909
开发语言是构建数字世界的核心工具，不同语言各有专长。Python主导AI与数据科学，​JavaScript为Web前端基石，​Java/C#​掌控企业级系统，​Go领跑云原生开发，​C/C++​制霸高性能领域，​Kotlin/Swift引领移动生态。选型需聚焦三要素：​场景适配性​（Web/移动/系统/数据）、性能需求层级​（从脚本到内核优化）、开发生态成熟度​（团队技术栈与。选型需关注四个维度：​应用场景​（Web/移动/系统/数据）、性能要求、团队技术栈及开发效率。理解语言特性比追求“万能语言”更重要。
Photoshop电子教案PPT学习课件.ppt
08-04
Photoshop电子教案PPT学习课件.ppt
移动通信技术与网络优化第6章路测.ppt
最新发布
08-04
移动通信技术与网络优化第6章路测.ppt
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值