数据结构：手把手教你写 C 语言双向循环链表（内含分模块功能函数实现）

🌈这里是say-fall分享，感兴趣欢迎三连与评论区留言
🔥专栏：《C语言从零开始到精通》《C语言编程实战》《数据结构与算法》《小游戏与项目》
💪格言：做好你自己，你才能吸引更多人，并与他们共赢，这才是你最好的成长方式。

---

前言：

之前已经带大家了解过单链表了，而相比单链表，双向链表作为一个带头双向循环链表，在实现各个功能方面都会相对简单一些，下面我们一起来看看这个双向链表的各个功能到底是怎么实现的，快来围观~

---

---

正文：

0. 码云源代码

• 码云源代码：双向链表

1. List.h 文件：数据结构与接口声明

该文件定义了链表的核心数据结构和所有对外提供的接口函数，是整个模块的"契约"。

#define _CRT_SECURE_NO_WARNINGS 1  // 禁用VS的安全函数警告
#include<stdio.h>    // 标准输入输出库，用于打印
#include<stdlib.h>   // 标准库，提供malloc/free等内存操作
#include<assert.h>   // 断言库，用于调试时的参数校验

// 数据类型别名定义，实现类型抽象
// 若需存储其他类型（如char/float），只需修改此处
typedef int typedata;

// 双向链表节点结构体定义
// 每个节点包含数据域和两个指针域（前驱/后继）
typedef struct ListNode
{
	typedata val;          // 数据域：存储节点值
	struct ListNode* next; // 指针域：指向下一个节点
	struct ListNode* prev; // 指针域：指向前一个节点
}LTNode;  // 结构体别名，简化后续使用

// 接口函数声明（API）

// 链表初始化：创建并返回哨兵位头节点
LTNode* LTInit();

// 创建新节点：封装节点创建逻辑，返回新节点指针
LTNode* Buynode(typedata x);

// 链表打印：遍历并输出所有有效节点数据
void LTprint(LTNode* head);

// 尾插操作：在链表尾部插入新节点
void LTPushBack(LTNode* head, typedata x);

// 头插操作：在链表头部（哨兵位后）插入新节点
void LTPushFront(LTNode* head, typedata x);

// 尾删操作：删除链表尾部节点
void LTpopBack(LTNode* head);

// 头删操作：删除链表头部（哨兵位后）节点
void LTpopFront(LTNode* head);

// 节点查找：根据值查找节点，返回节点指针（未找到返回NULL）
LTNode* LTFind(LTNode* head, typedata x);

// 指定位置插入：在pos节点之后插入新节点
void LTInsert(LTNode* pos, typedata x);

// 指定位置删除：删除pos指向的节点
void LTErase(LTNode* pos);

// 链表销毁：释放所有节点内存
void LTDestroy(LTNode* phead);

技术要点说明：

• 类型抽象：通过typedef int typedata实现数据类型的解耦，增强代码复用性
• 结构体设计：双向链表节点必须包含前驱和后继指针，支持双向遍历
• 接口设计原则：函数命名采用前缀（LT）区分模块，参数清晰，功能单一

---

2. List.c 文件：核心功能实现

该文件是链表功能的具体实现，包含所有接口函数的定义。

2.1 链表初始化 (LTInit)

#include"List.h"  // 包含头文件，获取数据结构和函数声明

// 初始化链表：创建哨兵位头节点
LTNode* LTInit()
{
	// 创建哨兵位节点（值为-1，标识为无效数据）
	LTNode* head = Buynode(-1);
	return head; // 返回头节点指针
}

技术解析：

• 哨兵位设计：哨兵位（Sentinel）是不存储有效数据的头节点，作用是：
  1. 统一空链表和非空链表的操作逻辑
  2. 避免边界条件的复杂判断
  3. 简化头尾操作的实现

2.2 节点创建 (Buynode)

// 创建新节点：内存分配+初始化
LTNode* Buynode(typedata x)
{
	// 动态内存分配：sizeof(LTNode)计算节点所需字节数
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	
	// 初始化节点指针：新节点自循环（自身前驱后继均指向自己）
	node->next = node->prev = node;
	node->val = x; // 设置节点数据
	
	return node; // 返回新节点地址
}

技术解析：

• 内存管理：使用malloc动态分配内存，节点生命周期由程序员控制
• 自循环初始化：新节点默认自循环，确保插入链表前的完整性

2.3 链表打印 (LTprint)

// 打印链表：遍历输出所有有效节点
void LTprint(LTNode* head)
{
	assert(head); // 断言：确保head不为空指针（调试阶段有效）
	
	// 从第一个有效节点开始遍历（哨兵位的后继节点）
	LTNode* pcur = head->next;
	
	// 循环条件：未回到哨兵位（循环链表遍历终止条件）
	while (pcur != head)
	{
		printf("%d -> ", pcur->val); // 输出当前节点值
		pcur = pcur->next;           // 移动到下一个节点
	}
	printf("\n"); // 换行，美化输出
}

技术解析：

• 断言机制：assert(head)在调试模式下检查指针有效性，崩溃时快速定位问题
• 遍历逻辑：双向循环链表的遍历以回到头节点作为终止条件

2.4 尾插操作 (LTPushBack)

// 尾插操作：在链表尾部添加节点
void LTPushBack(LTNode* head, typedata x)
{
	assert(head); // 参数校验
	LTNode* newnode = Buynode(x); // 创建新节点
	
	// 指针调整四步法（关键操作）：
	newnode->next = head;          // 1. 新节点后继指向哨兵位
	newnode->prev = head->prev;    // 2. 新节点前驱指向原尾节点
	head->prev->next = newnode;    // 3. 原尾节点后继指向新节点
	head->prev = newnode;          // 4. 哨兵位前驱指向新节点（更新尾节点）
}

技术解析：

• 指针操作顺序：先处理新节点的指针，再修改原链表的指针，避免链表断裂
• 时间复杂度：O(1)，直接通过head->prev定位尾节点，无需遍历

2.5 头插操作 (LTPushFront)

// 头插操作：在链表头部添加节点
void LTPushFront(LTNode* head, typedata x)
{
	assert(head);
	LTNode* newnode = Buynode(x);
	
	// 指针调整：
	newnode->next = head->next;    // 1. 新节点后继指向原首节点
	newnode->prev = head;          // 2. 新节点前驱指向哨兵位
	head->next->prev = newnode;    // 3. 原首节点前驱指向新节点
	head->next = newnode;          // 4. 哨兵位后继指向新节点（更新首节点）
}

技术解析：

• 头插逻辑：新节点插入哨兵位和原首节点之间
• 时间复杂度：O(1)，直接操作指针，无需遍历

2.6 头删操作 (LTpopFront)

// 头删操作：删除链表首节点
void LTpopFront(LTNode* head)
{
	// 双重断言：确保链表非空（至少有哨兵位+一个有效节点）
	assert(head != NULL && head->next != head);
	
	LTNode* delnode = head->next; // 标记要删除的节点
	
	// 指针调整：
	head->next = delnode->next;    // 1. 哨兵位后继指向次节点
	delnode->next->prev = head;    // 2. 次节点前驱指向哨兵位
	
	free(delnode); // 释放节点内存（避免内存泄漏）
	delnode = NULL; // 指针置空（避免野指针）
}

技术解析：

• 边界条件检查：head->next != head确保链表非空
• 内存释放：free(delnode)释放节点占用的内存
• 野指针预防：delnode = NULL将指针置空，避免悬空指针

2.7 尾删操作 (LTpopBack)

// 尾删操作：删除链表尾节点
void LTpopBack(LTNode* head)
{
	assert(head != NULL && head->next != head); // 非空检查
	
	LTNode* delnode = head->prev; // 标记尾节点
	
	// 指针调整：
	head->prev = head->prev->prev; // 1. 哨兵位前驱指向倒数第二个节点
	head->prev->next = head;       // 2. 倒数第二个节点后继指向哨兵位
	
	free(delnode); // 释放内存
	delnode = NULL;
}

技术解析：

• 尾节点定位：通过head->prev直接获取尾节点，无需遍历
• 时间复杂度：O(1)，效率高于单链表

2.8 节点查找 (LTFind)

// 节点查找：按值查找节点
LTNode* LTFind(LTNode* head, typedata x)
{
	assert(head);
	
	// 空链表判断：直接返回NULL
	if (head->next == head)
	{
		return NULL;
	}
	
	LTNode* pcur = head->next; // 从首节点开始遍历
	
	while (pcur != head) // 遍历终止条件
	{
		if (pcur->val == x) // 找到目标值
		{
			return pcur; // 返回节点指针
		}
		pcur = pcur->next; // 继续遍历
	}
	
	return NULL; // 未找到返回NULL
}

技术解析：

• 线性查找：链表查找只能顺序遍历，时间复杂度O(n)
• 返回值设计：找到返回节点指针，未找到返回NULL，语义清晰

2.9 指定位置插入 (LTInsert)

// 指定位置插入：在pos节点后插入新节点
void LTInsert(LTNode* pos, typedata x)
{
	assert(pos); // 确保pos有效
	
	LTNode* newnode = Buynode(x); // 创建新节点
	
	// 指针调整：
	newnode->prev = pos;           // 1. 新节点前驱指向pos
	newnode->next = pos->next;     // 2. 新节点后继指向pos的后继
	pos->next->prev = newnode;     // 3. pos后继的前驱指向新节点
	pos->next = newnode;           // 4. pos的后继指向新节点
}

技术解析：

• 通用插入函数：头插和尾插均可通过此函数实现：
  • 头插：LTInsert(head, x)
  • 尾插：LTInsert(head->prev, x)
• 解耦设计：将通用插入逻辑抽象为独立函数，减少代码冗余

2.10 指定位置删除 (LTErase)

// 指定位置删除：删除pos节点
void LTErase(LTNode* pos)
{
	assert(pos);                  // 确保pos有效
	assert(pos->next != pos);     // 确保不是唯一的哨兵位
	
	// 指针调整：跳过pos节点
	pos->prev->next = pos->next;  // 1. pos前驱的后继指向pos的后继
	pos->next->prev = pos->prev;  // 2. pos后继的前驱指向pos的前驱
	
	free(pos); // 释放节点内存
	pos = NULL;
}

技术解析：

• 通用删除函数：头删和尾删均可通过此函数实现：
  • 头删：LTErase(head->next)
  • 尾删：LTErase(head->prev)
• 安全性检查：pos->next != pos防止删除哨兵位

2.11 链表销毁 (LTDestroy)

// 链表销毁：释放所有节点内存
void LTDestroy(LTNode* head)
{
	assert(head);
	
	LTNode* pcur = head->next; // 从首节点开始
	
	// 遍历并释放所有有效节点
	while (pcur != head)
	{
		LTNode* next = pcur->next; // 保存下一个节点地址
		free(pcur);                // 释放当前节点
		pcur = next;               // 移动到下一个节点
	}
	
	free(head); // 最后释放哨兵位
	head = NULL; // 指针置空
}

技术解析：

• 销毁顺序：先释放有效节点，最后释放哨兵位
• 内存管理：动态分配的内存必须手动释放，否则造成内存泄漏
• 野指针处理：释放后指针置空，避免悬空指针

---

3. Test.c 文件：功能测试与验证

该文件是链表功能的测试用例，验证所有接口的正确性。

#include"List.h" // 包含链表接口

void test1()
{
	// 1. 初始化链表
	LTNode* plist = LTInit();
	LTNode* head = plist;
	
	// 2. 尾插测试
	LTPushBack(head, 1);
	LTPushBack(head, 2);
	LTPushBack(head, 3);
	LTPushBack(head, 4);
	LTprint(head); // 预期输出：1 -> 2 -> 3 -> 4 ->
	
	// 3. 头插测试
	LTPushFront(head, 2);
	LTPushFront(head, 3);
	LTPushFront(head, 4);
	LTprint(head); // 预期输出：4 -> 3 -> 2 -> 1 -> 2 -> 3 -> 4 ->
	
	// 4. 尾删测试
	LTpopBack(head);
	LTprint(head); // 预期输出：4 -> 3 -> 2 -> 1 -> 2 -> 3 ->
	
	// 5. 头删测试
	LTpopFront(head);
	LTprint(head); // 预期输出：3 -> 2 -> 1 -> 2 -> 3 ->
	
	// 6. 查找测试
	LTNode* find = LTFind(head,1);
	printf("%p\n", find); // 输出找到的节点地址
	
	// 7. 指定位置插入测试
	LTInsert(find,1);
	LTInsert(find,1);
	LTprint(head); // 预期输出：3 -> 2 -> 1 -> 1 -> 1 -> 2 -> 3 ->
	
	// 8. 指定位置删除测试
	LTErase(find);
	LTprint(head); // 预期输出：3 -> 2 -> 1 -> 1 -> 2 -> 3 ->
	
	// 9. 链表销毁
	LTDestroy(head);
	head = NULL;
}

int main()
{
	test1(); // 执行测试用例
	return 0;
}

测试设计思路：

• 全覆盖测试：测试所有接口函数
• 增量测试：逐步构建测试场景，便于定位问题
• 可视化验证：通过打印输出直观验证操作结果
• 资源清理：测试结束销毁链表，避免内存泄漏

---

总结

1. 数据结构优势：带头双向循环链表结合了双向链表和循环链表的优点，头尾操作均为O(1)时间复杂度，是综合性能最优的链表结构。
2. 设计模式应用：哨兵位模式简化了边界条件处理，封装模式（Buynode）隐藏了节点创建细节。
3. 内存管理原则：动态内存分配需遵循"谁申请，谁释放"原则，避免内存泄漏和野指针。
4. 代码复用技巧：通过通用的Insert/Erase函数实现头插/尾插/头删/尾删，减少代码冗余。

---

• 本节完…