C语言数据结构——双向链表

最新推荐文章于 2026-06-24 17:55:42 发布
原创 最新推荐文章于 2026-06-24 17:55:42 发布 · 102 阅读 · 4 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#数据结构 #c语言 #链表

C语言数据结构——双向链表

我们之前学的单链表有两个致命短板：

  1. 尾插 / 尾删必须遍历整条链表，时间复杂度 O(N)
  2. 只能单向遍历，找前驱节点极其麻烦

而带头双向循环链表完美解决了以上所有问题

文章目录

一、 知识铺垫

1、链表 8 种分类

链表由 3 个维度组合划分，一共 2×2×2=8 种结构：

  1. 单向 / 双向：单向只有后继指针next；双向同时有next后继、prev前驱指针
  2. 带头 / 不带头：头节点（哨兵位）不存有效数据，仅占位，统一空链表与非空链表操作逻辑
  3. 循环 / 不循环：尾节点next是否指向头节点，循环链表尾节点可直接通过head->prev拿到

在这里插入图片描述

上篇文章讲单链表的时候，为了方便讲解我把第一个结点称为头结点其实是不准确的，头结点指的是哨兵位，不储存任何有效数据，只是用来占位置。

所以单链表全称为单向不带头不循环链表

而本片文章讲的是双向带头循环链表，简称双向链表

2、双向链表

双向链表的优势：

  1. 自带哨兵头节点，空链表和有数据链表操作代码完全一致，无需特殊判断
  2. 双向指针，任意节点可直接访问前驱、后继
  3. 循环结构，head->prev 直接拿到尾节点，尾插尾删不用遍历
  4. 所有增删操作时间复杂度稳定 O(1)

在这里插入图片描述

二、双向链表节点结构定义

1、结构体代码（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;	//指向前一个结点（前驱）
}LTNode;

2、节点结构

每个节点三块内容：数据data + 后继指针next + 前驱指针prev

  • 头节点（哨兵）：data=-1 占位，不存业务数据
  • 空链表状态：头节点next和prev都指向自己，形成自循环
  • 非空链表：尾节点next指向头节点，头节点prev指向尾节点

在这里插入图片描述

三、基础功能实现

所有函数实现放在List.c，测试代码放在test.c

1、新建单个节点 LTBuyNode

我们插入数据时，经常需要开辟空间存放数据，可以把函数封装起来，复用代码

LTNode* LTBuyNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	//内存分配失败直接退出程序
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	//新节点默认自循环(空结点标准状态)
	newnode->next = newnode->prev = newnode;
	return newnode;
}

2、链表初始化 LTInit

2种初始化方案，我们选择一级指针返回头节点（推荐）：

  • 旧方案（二级指针void LTInit(LTNode ** pphead)） ：需要传地址，接口不统一
  • 新方案（LTNode * LTInit()）：直接返回哨兵头节点，调用简单。
//双向链表初始化
// 旧方案
//void LTInit(LTNode** pphead)
//{
//	assert(pphead);
//	*pphead = LTBuyNode(-1);
//}

//新方案
LTNode* LTInit()
{
	//创建哨兵头结点，data随便填-1占位
	LTNode* phead = LTBuyNode(-1);
	return phead;
}

调用示例：LTNode * plist = LTInit();

3、打印链表 LTPrint

循环条件：从第一个有效节点phead->next开始，回到phead停止

//打印
void LTPrint(LTNode* phead)
{
	assert(phead);	//防止传入空指针
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		printf("%d -> ", pcur->data);
		pcur = pcur->next;
	}
	printf("\n");
}

4、判断链表是否为空 LTEmpty

空链表判定条件：头节点的后继等于自己

bool LTEmpty(LTNode* phead)
{
	assert(phead);
	return phead->next == phead;
}

5、尾插 LTPushBack（O (1)，单向链表做不到）

逻辑：新节点插在phead和phead->prev（尾节点）中间

指针修改四步固定步骤：

  1. 新节点前驱 = 原尾节点 newnode->prev = phead->prev
  2. 新节点后继 = 头节点 newnode->next = phead
  3. 原尾节点后继 = 新节点 phead->prev->next = newnode
  4. 头节点前驱 = 新节点 phead->prev = newnode

一般是先让新节点的指针挂上非哨兵位，再挂上哨兵位；再调整非哨兵位的指针，最后再调整头结点的指针

在这里插入图片描述

//不改变头结点地址，因此只许传入一级指针
//尾插
void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);
	//绑定新节点、尾结点、头结点
	newnode->prev = phead->prev;
	newnode->next = phead;

	phead->prev->next = newnode;
	phead->prev = newnode;
}

6、头插LTPushFront

逻辑：新节点插在phead和phead->next（首节点）中间
在这里插入图片描述

void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);

	//绑定新节点、首节点、头节点
	newnode->next = phead->next;
	newnode->prev = phead;

	phead->next->prev = newnode;
	phead->next = newnode;
}

7、尾删 LTPopBack

前置判断：链表不能为空，否则断言报错

直接取phead->prev为待删除尾节点，先修改头尾指针，后释放内存
在这里插入图片描述

void LTPopBack(LTNode* phead)
{
	assert(!LTEmpty(phead));//空链表禁止删除
	LTNode* del = phead->prev;	//避免指针太长用新变量来取代原尾结点
	
	//跳过待删除结点，重连头尾
	del->prev->next = phead;
	phead->prev = del->prev;

	free(del);
	del = NULL;
}

8、头删 LTPopFront

取phead->next为首节点，先重连前后指针，后释放
在这里插入图片描述

oid LTPopFront(LTNode* phead)
{
	assert(!LTEmpty(phead));
	LTNode* del = phead->next;	//原第一个结点

	del->next->prev = phead;
	phead->next = del->next;

	free(del);
	del = NULL;
}

9、查找节点 LTFind

遍历链表，匹配data则返回节点指针，无匹配返回NULL
返回指针可用于后续指定位置插入 / 删除

LTNode* LTFind(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

10、指定 pos 节点后插入 LTInsert

任意节点后插入通用模板，pos 可通过LTFind获取
在这里插入图片描述

void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* newnode = LTBuyNode(x);
	
	newnode->next = pos->next;
	newnode->prev = pos;

	pos->next->prev = newnode;
	pos->next = newnode;
}

11、删除指定 pos 节点 LTErase

直接跳过 pos 节点，重连前后指针，释放内存
注意：pos 不能是头节点（哨兵不允许删除）
在这里插入图片描述

void LTErase(LTNode* pos)
{
	assert(pos);
	pos->next->prev = pos->prev;
	pos->prev->next = pos->next;

	free(pos);
	pos = NULL;
}

12、链表销毁 LTDesTroy

循环释放所有有效节点，最后释放哨兵头节点
注意：函数内phead=NULL仅修改形参，外部实参需要手动置空

//销毁
//版本一，需要传二级指针，与其他代码接口不统一
//void LTDesTroy(LTNode** pphead)
//{
//	LTNode* pcur = (*pphead)->next;
//	while (pcur != *pphead)
//	{
//		LTNode* next = pcur->next;
//		free(pcur);
//		pcur = next;
//	}
//	free(*pphead);
//	*pphead = 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;
}

外部调用规范：
LTDesTroy(plist);
plist = NULL; // 手动置空，避免野指针

四、完整测试代码test.c

#include"List.h"

void test01()
{
	// 1. 初始化链表（创建哨兵头节点）
	LTNode* plist = LTInit();

	// 2. 尾插测试
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	printf("尾插1 2 3 4：");
	LTPrint(plist); // 输出：1 -> 2 -> 3 -> 4 -> 

	// 3. 头插测试
	LTPushFront(plist, 0);
	printf("头插0：");
	LTPrint(plist); // 输出：0 -> 1 -> 2 -> 3 -> 4 ->

	// 4. 查找+指定位置插入
	LTNode* find = LTFind(plist, 2);
	if (find != NULL)
	{
		LTInsert(find, 100);
		printf("在2后插入100：");
		LTPrint(plist); // 0 -> 1 -> 2 -> 100 -> 3 -> 4 ->
	}

	// 5. 尾删、头删
	LTPopBack(plist);
	printf("尾删：");
	LTPrint(plist);
	LTPopFront(plist);
	printf("头删：");
	LTPrint(plist);

	// 6. 删除指定节点
	LTErase(find);
	printf("删除值为2的节点：");
	LTPrint(plist);

	// 7. 销毁链表，防止内存泄漏
	LTDesTroy(plist);
	plist = NULL;
}

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

在这里插入图片描述

五、双向链表 vs 顺序表（数组）

对比维度顺序表（数组）带头双向循环链表
物理空间连续一块内存离散碎片化内存，靠指针串联
随机访问支持，下标 O(1)访问不支持，必须遍历 O(N)
头部 / 中部插入删除O(N)，需要整体挪动数据O(1)，仅修改指针
尾插尾删无扩容时 O(1)；扩容 O(N)永久 O(1)，无扩容开销
内存开销仅存储数据，开销小每个节点多 2 个指针，额外开销大
适用场景频繁查询、极少插入删除频繁增删、查询少，长度波动大

六、完整实现代码

1、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;	//指向前一个结点（前驱）
}LTNode;


void LTPrint(LTNode* phead);

//双向链表的初始化
//void LTInit(LTNode** pphead);
LTNode* LTInit();

//销毁
//传二级：违背了接口的一致性
//void LTDesTroy(LTNode** pphead);
//传一级：调用完成之后将实参手动置为NULL（推荐）
void LTDesTroy(LTNode* phead);

//头结点要发生改变传二级
//头结点不发生改变，传一级

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

//判断是否为空
bool LTEmpty(LTNode* phead);
//尾删
void LTPopBack(LTNode* phead);
//头删
void LTPopFront(LTNode* phead);

//查找
LTNode* LTFind(LTNode* phead, LTDataType x);
//在pos位置之后插入数据
void LTInsert(LTNode* pos, LTDataType x);

//删除pos位置的结点
void LTErase(LTNode* pos);

2、List.c

#define _CRT_SECURE_NO_WARNINGS
#include"List.h"

LTNode* LTBuyNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	//内存分配失败直接退出程序
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	//新节点默认自循环(空结点标准状态)
	newnode->next = newnode->prev = newnode;
	return newnode;
}

//双向链表初始化
// 旧方案
//void LTInit(LTNode** pphead)
//{
//	assert(pphead);
//	*pphead = LTBuyNode(-1);
//}

//新方案
LTNode* LTInit()
{
	//创建哨兵头结点，data随便填-1占位
	LTNode* phead = LTBuyNode(-1);
	return phead;
}


//打印
void LTPrint(LTNode* phead)
{
	assert(phead);	//防止传入空指针
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		printf("%d -> ", pcur->data);
		pcur = pcur->next;
	}
	printf("\n");
}


bool LTEmpty(LTNode* phead)
{
	assert(phead);
	return phead->next == phead;
}

//不改变头结点地址，因此只许传入一级指针
//尾插
void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);
	//绑定新节点、尾结点、头结点
	newnode->prev = phead->prev;
	newnode->next = phead;

	phead->prev->next = newnode;
	phead->prev = newnode;
}


void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);

	//绑定新节点、首节点、头节点
	newnode->next = phead->next;
	newnode->prev = phead;

	phead->next->prev = newnode;
	phead->next = newnode;
}


void LTPopBack(LTNode* phead)
{
	assert(!LTEmpty(phead));//空链表禁止删除
	LTNode* del = phead->prev;	//避免指针太长用新变量来取代原尾结点
	
	//跳过待删除结点，重连头尾
	del->prev->next = phead;
	phead->prev = del->prev;

	free(del);
	del = NULL;
}

void LTPopFront(LTNode* phead)
{
	assert(!LTEmpty(phead));
	LTNode* del = phead->next;	//原第一个结点

	del->next->prev = phead;
	phead->next = del->next;

	free(del);
	del = NULL;
}

LTNode* LTFind(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}


void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* newnode = LTBuyNode(x);
	
	newnode->next = pos->next;
	newnode->prev = pos;

	pos->next->prev = newnode;
	pos->next = newnode;
}

void LTErase(LTNode* pos)
{
	assert(pos);
	pos->next->prev = pos->prev;
	pos->prev->next = pos->next;

	free(pos);
	pos = NULL;
}

//销毁
//版本一，需要传二级指针，与其他代码接口不统一
//void LTDesTroy(LTNode** pphead)
//{
//	LTNode* pcur = (*pphead)->next;
//	while (pcur != *pphead)
//	{
//		LTNode* next = pcur->next;
//		free(pcur);
//		pcur = next;
//	}
//	free(*pphead);
//	*pphead = 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;
}
数据结构-双向链表(C语言)
m0_49408252的博客
01-15 1179
unionunion为使链表具有通用性，在节点中只定义指针部分，数据部分通过自定义结构体的方式定义。dnode node;char* name;node使得my_data_t可作为节点链接在链表中，my_data_t中数据可随实际情况改变。双向链表中定义head和tail分别指向链表的头和尾。
数据结构——单向链表和双向链表的实现（C语言版）
2301_79171011的博客
02-09 3774
这篇文章关于链表的介绍，还有单向链表和双向链表的C语言实现，内容干货满满，建议边看边上手敲代码！通过这篇文章，相信你已经对链表这个数据结构有了一定的了解，可以开始刷一些链表的OJ题目。如果只是看了一遍，建议上手敲敲代码，实践出真知。创作不易，希望这篇文章能给你带来启发和帮助，如果喜欢这篇文章，请留下你的三连哦，你的支持的我最大的动力！！！
数据结构之双向链表C语言版
Cukor丘克的博客
10-06 601
数据结构之双向链表C语言版 文章目录数据结构之双向链表C语言版双向链表长什么样？双向链表的节点的结构体双向链表的链表再封装包含的头文件各个子函数的实现创建节点创建链表表头法插入数据表尾法插入数据指定位置插入数据顺序打印链表数据逆序打印链表数据表头法删除数据表尾法删除数据指定位置删除数据主函数测试 数据结构就是用来存放数据的，有很多种数据结构，这篇文章写的是双向链表，用C语言实现。学习数据结构的时候直接复制粘贴源代码是没什么用的。不知道数据结构内部的实现，等于没学。 双向链表长什么样？ 在了解一个数据结构之前
数据结构——双向链表（C语言版）
2301_80220607的博客
03-24 2000
数据结构双向链表简单直白讲解
数据结构之C语言实现双向链表
煮酒论英雄
07-07 8072
C语言实现双向链表 双向链表主要实现以下功能： 双向链表创建 节点头插 节点尾插 指定位置插入节点 节点删除 链表排序 链表求长 /****************************************************************************************************** * function：自定义一个...
算法与数据结构之Floyd算法
weixin_73953650的博客
06-20 522
超详细的Floyd算法教程，一看就懂！
Hermes Agent 技能进化系统拆解：Skill 的元数据结构、自注册加载与退化机制 [07]
Starry-SkyJing的博客
06-22 130
[07] Hermes Agent 技能进化系统拆解：Skill 的元数据结构、自注册加载与退化机制 > TL;DR：Skill 不是静态的文档——它是 Agent 的"程序性记忆"系统。SKILL
C/C++ 数据结构（十一）树
2301_80252792的博客
06-22 317
本文系统介绍了树结构基础与二叉树核心知识。主要内容包括：1.树的基础概念与术语（节点关系、度、深度等）；2.二叉树的数学特性、存储方式（链式/顺序）及堆结构；3.四种遍历算法（前/中/后序递归非递归实现，层序队列实现）；4.常用递归操作（求高、节点计数、插入删除）；5.应用实例（二叉搜索树、四/八叉树的游戏优化原理）。重点强调了完全二叉树与普通二叉树的区别，以及递归在树操作中的核心作用，为数据结构学习提供了完整框架。
数据结构基础复习——排序算法的关键代码片段
2301_80025611的博客
06-22 354
针对数据结构考试中常见的代码填空题，我为你整理了上述核心排序算法的关键代码片段。考试时，出题人通常会挖空或。
Pulseaudio进阶开发之核心数据结构串联播放链路(三十)
Android系统攻城狮
06-22 1392
本篇目的：Pulseaudio进阶开发之11个核心数据结构串联播放链路。
Redis 数据结构
土司先生的博客
06-22 261
redis 的 string , list 队列，Set 集，的数据结构讲解
C/C++ 数据结构（十）深搜广搜补充，A*算法
2301_80252792的博客
06-22 198
本文系统介绍了三种经典寻路算法： BFS广度优先搜索：基于队列实现分层扩散，天然保证最短路径，适用于迷宫寻路等场景，通过前驱数组回溯路径。 DFS深度优先搜索：递归实现栈结构，代码简洁但无法保证最优解，适合全图遍历，需注意栈溢出风险。 A*启发式算法：融合实际代价G与启发估值H（曼哈顿/欧式距离），通过Open/Close列表动态筛选路径，兼顾效率与最优性，是游戏和导航领域的工业标准。文中对比了三者特性，并给出完整代码框架及优化方向（如优先队列优化Open列表），突显A*在复杂场景下的综合优势。
关于内存碎片化对数据结构操作性能的影响研究的技术7
最新发布
平头的博客
06-24 153
【代码】关于内存碎片化对数据结构操作性能的影响研究的技术7。
【数据结构】核心数据结构解析：跳表（Skip List）从底层原理到经典对比
2503_91154453的博客
06-24 95
数据结构 : 跳表,范围查询, 和B+树的区别
C++算法：哈希表
2501_90377063的博客
06-23 233
创建哈希表，key为string，value为vector< string >，遍历strs，把遍历到的strs的元素先保存为s然后排序，再hash[s].push_back()。哈希表存储的键值对为 < nums[i]，i > ，如果从前往后遍历，对于[2，7，4，15]，target=8，先把元素和下标放入哈希表。遍历数组到2，然后在哈希表中查找是否有6，没有则继续遍历，当遍历到4时，哈希表中有4，但是这二者是同一个4，此时要处理这个特殊情况。用数组作为哈希表，下标对应字符，元素为该字符出现的次数。
Redis 缓存学习笔记（一）：缓存基础与底层数据结构
bllovepigpig的博客
06-23 328
key 是快递，slot 是格子，Redis 节点是仓库管理员。一个快递只进一个格子，一个格子只归一个管理员管，但一个管理员要管很多格子。
我的数据结构1
ChaoZiLL的博客
06-17 302
首先将数组的数据全部进行异或(^)操作，得到一个值a，再将该值与取负(原码取反+1)，得到(-a),将a与(-a)进行与(&)运算得到key值，key值就意味着该组数据中可以从右往左边数第几位为1，在使用key值作为分组的桥梁，是的同一组内的不同值再进行一次异或(^)操作，最后留下来的数就是需要的答案了；礼盒中除了一款撞色搭配的袜子，每种颜色的袜子均有两只。第一种：使用计数排序的思路从而找出缺失的数，但这样的空间复杂度是O(N)，因为要遍历数组，时间复杂度也是O(N)；的所有整数，但其中缺了一个。
ACM CSP竞赛笔记（七）——数据结构-栈与前中后缀表达式
2301_80226956的博客
06-20 210
栈在表达式计算中的应用，包括前缀、后缀表达式的计算方法
江苏专转本数据结构
大今野
06-24 83
江苏专转本数据结构
C/C++ 数据结构（十二）平衡二叉树、红黑树
2301_80252792的博客
06-23 288
本文系统介绍了平衡二叉搜索树的核心知识，重点剖析了AVL树和红黑树的实现原理与特性差异。主要内容包括：1）AVL树的严格平衡机制（平衡因子、四种失衡类型及旋转调整）；2）红黑树的五大约束规则及其弱平衡特性；3）STL中map/set基于红黑树的实现原理与使用规范；4）不同场景下红黑树容器与哈希表的选型策略；5）游戏开发中四叉树/八叉树的空间优化应用。通过对比分析AVL树与红黑树在查询、插入性能上的差异，为工程实践提供数据结构选型依据
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值