• 带头双向循环链表（最6的链表结构,数据结构必看）

    之前我介绍了单向不带头链表，相信大家在敲完链表整体代码并且刷完那十一道经典题以后，肯定已经对链表了如指掌了。并且在这过程中，大家也能感受到比起顺序表，链表还是挺方便的，但是还是有美中不足的地方，比如说，插入结点时要判断是否是头插，传参时得传二级指针等等，这些如何去解决呢？我就再为大家介绍一个超级无敌巨好用的链表——带头双向循环链表。这个链表并不常见，这是某位大佬博览群书最终得出的结果，而我今天就站在巨人的肩膀上为大家剖析一下这个链表结构。

    目录

    1、链表结构 

    1.1 链表结构解析

    1.2 结点构建

    2、链表功能介绍

    3、功能的实现

    3.1 创建返回链表的头结点

    3.2 创建一个新的结点

    3.3 打印带头双向循环链表 

    3.4 链表结点查找

    3.5 在pos之前插入结点

    3.6 删除pos位置的结点

    3.7 判断链表是否为空

    3.8 链表的头删

    3.9 链表的尾删

    3.10 链表的头插和尾插

    3.11 链表长度计算

    3.12 链表的销毁

    4、源代码 

    1、链表结构 

    1.1 链表结构解析

    带头——带哨兵头结点（guard结点，这个我在经典十一题里面已经介绍过了） 

     双向——一个结点结构体中包含三个成员：val（记录有效数值）、next（指向下一个结点）、prev（指向上一个结点）

    循环——首尾都是相连的（看图看图看图），并且整个链表中没有NULL。

    1.2 结点构建

    1. typedef int LTDataType;
    2. typedef struct ListNode
    3. {
    4. 	LTDataType val;
    5. 	struct ListNode* prev;
    6. 	struct ListNode* next;
    7. }ListNode;

    这一块跟普通链表没区别，我就不赘述了。

    2、链表功能介绍

    功能这一块也跟链表是一样的，对数据进行增删查改。

    1. //创建返回链表的头结点
    2. ListNode* ListCreate();
    3. //创建一个新的结点
    4. ListNode* NodeCreate(LTDataType x);
    5. //打印带头双向循环链表
    6. void ListPrint(ListNode* guard);
    7. //双向链表头插
    8. void ListPushFront(ListNode* guard,LTDataType x);
    9. //链表尾插
    10. void ListPushBack(ListNode* guard, LTDataType x);
    11. //判断链表是否为空
    12. bool ListEmpty(ListNode* guard);
    13. //链表头删
    14. void ListPopFront(ListNode* guard);
    15. //链表尾删
    16. void ListPopBack(ListNode* guard);
    17. //链表长度
    18. size_t ListSize(ListNode* guard);
    19. //链表查找
    20. ListNode* NodeFind(ListNode* guard, LTDataType x);
    21. //在pos的前面进行插入
    22. void ListInsert(ListNode* pos, LTDataType x);
    23. //删除pos位置的结点
    24. void ListErase(ListNode* pos);
    25. //双向链表销毁
    26. void ListDestory(ListNode* guard);

    3、功能的实现

    唯有实践出真知，让我们一起在实现链表功能的过程中好好体会一下，这个王者链表有多好用。

    同时大家可以边学习边检查自己到底学没学会如何创建普通链表，我如果没有特别说明，就证明这个知识点肯定在普通链表中讲解过。

    3.1 创建返回链表的头结点

    这里需要注意一下：创建头结点的时候，因为链表中没有其它的数据，我们在初始化的时候让guard的next和prev都要指向自己，这样才是一个循环链表（如下图所示 ↓↓↓ ）

    1. ListNode* ListCreate()
    2. {
    3. 	struct ListNode* guard = (struct ListNode*)malloc(sizeof(struct ListNode));
    4. 	if (guard == NULL)
    5. 	{
    6. 		perror("malloc fail");
    7. 		exit(-1);
    8. 	}
    9. 	guard->next = guard;
    10. 	guard->prev = guard;
    11. 	return guard;
    12. }

    3.2 创建一个新的结点

    在VS2019中（准确来说在更高级一点的VS中），如果你在创建结点时不检验是否malloc成功，编译的时候就会报错，所以我们为了避免代码冗长，就单独写一个函数专门去创造一个新的结点。

    1. ListNode* NodeCreate(LTDataType x)
    2. {
    3. 	struct ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
    4. 	if (newnode == NULL)
    5. 	{
    6. 		perror("malloc newnode fail");
    7. 		exit(-1);
    8. 	}
    9. 	newnode->prev = NULL;
    10. 	newnode->next = NULL;
    11. 	newnode->val = x;
    12. 	return newnode;
    13. }

    3.3 打印带头双向循环链表 

    我之前说过，这个王者链表中的结点是没有NULL的，因此在判断循环是否要结束的条件应该是判断cur是否等于guard（这里有点小区别！！！）

    1. void ListPrint(ListNode* guard)
    2. {
    3. 	assert(guard);
    4. 	printf("guard<->");
    5. 	ListNode* cur = guard->next;
    6. 	//这种链表cur永远不可能为空
    7. 	while (cur!=guard)
    8. 	{
    9. 		printf("%d<->", cur->val);
    10. 		cur = cur->next;
    11. 	}
    12. 	printf("\n");
    13. }

    3.4 链表结点查找

    这个地方也没什么好说的。

    1. //链表查找
    2. ListNode* NodeFind(ListNode* guard, LTDataType x)
    3. {
    4. 	assert(guard);
    5. 	struct ListNode* cur = guard->next;
    6. 	while (cur != guard)
    7. 	{
    8. 		if (cur->val == x)
    9. 		{
    10. 			return cur;
    11. 		}
    12. 		cur = cur->next;
    13. 	}
    14. 	return NULL;
    15. }

    3.5 在pos之前插入结点

    emmm 我为什么要先介绍这个功能呢？因为等下就要施展魔法了。

    1. //在pos的前面进行插入
    2. void ListInsert(ListNode* pos, LTDataType x)
    3. {
    4. 	assert(pos);
    5. 	struct ListNode* prev = pos->prev;
    6. 	struct ListNode* newnode = NodeCreate(x);
    7. 	prev->next = newnode;
    8. 	newnode->prev = prev;
    9. 	newnode->next = pos;
    10. 	pos->prev = newnode;
    11. }

    3.6 删除pos位置的结点

    注意：这个地方很容易就搞不清谁指向谁了，我建议大家可以先定义两个结点记录pos->prev和pos->next，不然很容易就会搞错的。

    1. //删除pos位置的结点
    2. void ListErase(ListNode* pos)
    3. {
    4. 	assert(pos);
    5. 	struct ListNode* prev = pos->prev;
    6. 	struct ListNode* next = pos->next;
    7. 	prev->next = next;
    8. 	next->prev = prev;
    9. 	free(pos);
    10. 	pos = NULL;
    11. }

    3.7 判断链表是否为空

    这个功能是新增的，主要还是为之后头删和尾删做准备，如果链表中只有哨兵结点，那么就返回true，如果还有其它结点，那么就返回false。

    1. //判断链表是否为空
    2. bool ListEmpty(ListNode* guard)
    3. {
    4. 	assert(guard);
    5. 	if (guard->next == guard)
    6. 	{
    7. 		return true;
    8. 	}
    9. 	else
    10. 		return false;
    11. }

    这个代码是很多人都会想到的，但是我们可以再简化一下代码，变成：

    1. //判断链表是否为空
    2. bool ListEmpty(ListNode* guard)
    3. {
    4. 	assert(guard);
    5. 	return guard->next=guard;
    6. }

    另外还要提一嘴，我们也要学会在C语言中学会bool变量，bool变量的值就是true或者false，同时我们还不要忘记在引用bool变量的时候引入头文件——#include。 

    3.8 链表的头删

    我们印象中常规的头删是如下代码所示，大家可能会有疑惑的地方我也用注释标注出来了：

    1. //链表头删
    2. void ListPopFront(ListNode* guard)
    3. {
    4. 	assert(guard);
    5. 	//万一链表中数据为空呢
    6.     //如果List是Empty，则返回true，！ListEmpty（guard）为0,断言就会生效
    7. 	assert(!ListEmpty(guard));
    8. 	//如果链表中除了guard就只有一个元素也没关系
    9. 	//最后guard自己指向自己
    10. 	ListNode* node = guard->next;
    11. 	ListNode* next = node->next;
    12. 	guard->next = next;
    13. 	next->prev = guard;
    14. 	free(node);
    15. 	node = NULL;//这只是在形式上改变了node，实际上是改变不了node的
    16. }

    但其实我们可以用ListErase函数实现头删和尾删，如果是头删，则把guard->next传过去，如果是尾删，我们就把guard->prev传过去，头结点和尾结点的位置都很好找（不像普通链表，我们删除的时候还要找尾tail），于是代码就可以简化如下：

    1. //链表头删
    2. void ListPopFront(ListNode* guard)
    3. {
    4. 	assert(guard);
    5. 	assert(!ListEmpty(guard));
    6. 	ListErase(guard->next);
    7. }

    3.9 链表的尾删

     常规：

    1. //链表尾删
    2. void ListPopBack(ListNode* guard)
    3. {
    4. 	assert(guard);
    5. 	assert(!ListEmpty(guard));
    6. 	struct ListNode* tail = guard->prev;
    7. 	struct ListNode* prev = tail->prev;
    8. 	guard->prev = prev;
    9. 	prev->next = guard;
    10. 	free(tail);
    11. 	tail = NULL;
    12. }

    简单：

    1. //链表尾删
    2. void ListPopBack(ListNode* guard)
    3. {
    4. 	assert(guard);
    5. 	assert(!ListEmpty(guard));
    6.     ListErase(guard->prev);
    7. }

    3.10 链表的头插和尾插

     头插和尾插也都可以用ListInsert函数来实现。

    1. //双向链表头插
    2. void ListPushFront(ListNode* guard,LTDataType x)
    3. {
    4. 	assert(guard);
    5. 	/*ListNode* next = guard->next;
    6. 	struct ListNode* newnode = NodeCreate(x);
    7. 	guard->next = newnode;
    8. 	newnode->prev = guard;
    9. 	newnode->next = next;
    10. 	next->prev = newnode;*/
    11. 	//其实头插可以更简单
    12. 	ListInsert(guard->next,x);
    13. }
    14.  
    15. //链表尾插
    16. void ListPushBack(ListNode* guard, LTDataType x)
    17. {
    18. 	assert(guard);
    19. 	/*ListNode* newnode = NodeCreate(x);
    20. 	ListNode* tail = guard->prev;
    21. 	tail->next = newnode;
    22. 	newnode->prev = tail;
    23. 	newnode->next = guard;
    24. 	guard->prev = newnode;*/
    25. 	//其实尾插可以更简单
    26. 	ListInsert(guard, x);
    27. }

    3.11 链表长度计算

    1. //链表长度
    2. size_t ListSize(ListNode* guard)
    3. {
    4. 	assert(guard);
    5. 	ListNode* cur = guard->next;
    6. 	size_t size = 0;
    7. 	while (cur != guard)
    8. 	{
    9. 		size++;
    10. 		cur = cur->next;
    11. 	}
    12. 	return  size;
    13. }

    链表长度计算的原理是很简单，但是这里有人可能会有疑惑：为什么不直接把链表的长度放到哨兵结点的val里面呢？何必要用函数的返回值记录链表的长度？

    因为结点的val是有类型的——LTDataType，如果LTDataType为char型，它能存储的最大数为128，如果超过了128，最后再让guard->val++就会有问题了。

    3.12 链表的销毁

    销毁链表有两种销毁方式，第一种就是在函数里面把guard指针置空，传参的时候传二级指针；第二种就是在函数外面把guard置空，传参的时候传一级指针。我个人建议还是选择第二种写法，这样能保证接口一致性。

    1. //双向链表销毁
    2. void ListDestory(ListNode* guard)
    3. {
    4. 	assert(guard);
    5. 	//可不能一开始就把guard free掉了，不然就没有循环结束的判断条件了
    6. 	ListNode* cur = guard->next;
    7. 	while (cur!=guard)
    8. 	{
    9. 		ListNode* next = cur->next;
    10. 		free(cur);
    11. 		cur = next;
    12. 	}
    13. 	free(guard);
    14. }

    最后我们只需要在调用ListDestroy函数处，将guard置空即可。

    4、源代码 

    DList.h

    1. #pragma once
    2. #include
    3. #include
    4. #include
    5. #include
    6. typedef int LTDataType;
    7. typedef struct ListNode
    8. {
    9. 	LTDataType val;
    10. 	struct ListNode* prev;
    11. 	struct ListNode* next;
    12. }ListNode;
    13.  
    14. //创建返回链表的头结点
    15. ListNode* ListCreate();
    16. //创建一个新的结点
    17. ListNode* NodeCreate(LTDataType x);
    18. //打印带头双向循环链表
    19. void ListPrint(ListNode* guard);
    20. //双向链表头插
    21. void ListPushFront(ListNode* guard,LTDataType x);
    22. //链表尾插
    23. void ListPushBack(ListNode* guard, LTDataType x);
    24. //判断链表是否为空
    25. bool ListEmpty(ListNode* guard);
    26. //链表头删
    27. void ListPopFront(ListNode* guard);
    28. //链表尾删
    29. void ListPopBack(ListNode* guard);
    30. //链表长度
    31. size_t ListSize(ListNode* guard);
    32. //链表查找
    33. ListNode* NodeFind(ListNode* guard, LTDataType x);
    34. //在pos的前面进行插入
    35. void ListInsert(ListNode* pos, LTDataType x);
    36. //删除pos位置的结点
    37. void ListErase(ListNode* pos);
    38. //双向链表销毁
    39. void ListDestory(ListNode* guard);

    DList.c

    1. #include"DList.h"
    2.  
    3. //创建返回链表的头结点
    4. ListNode* ListCreate()
    5. {
    6. 	struct ListNode* guard = (struct ListNode*)malloc(sizeof(struct ListNode));
    7. 	if (guard == NULL)
    8. 	{
    9. 		perror("malloc fail");
    10. 		exit(-1);
    11. 	}
    12. 	guard->next = guard;
    13. 	guard->prev = guard;
    14. 	return guard;
    15. }
    16.  
    17. //创建一个新的结点
    18. ListNode* NodeCreate(LTDataType x)
    19. {
    20. 	struct ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
    21. 	if (newnode == NULL)
    22. 	{
    23. 		perror("malloc newnode fail");
    24. 		exit(-1);
    25. 	}
    26. 	newnode->prev = NULL;
    27. 	newnode->next = NULL;
    28. 	newnode->val = x;
    29. 	return newnode;
    30. }
    31.  
    32.  
    33. //打印带头双向循环链表
    34. void ListPrint(ListNode* guard)
    35. {
    36. 	assert(guard);
    37. 	printf("guard<->");
    38. 	ListNode* cur = guard->next;
    39. 	//这种链表cur永远不可能为空
    40. 	while (cur!=guard)
    41. 	{
    42. 		printf("%d<->", cur->val);
    43. 		cur = cur->next;
    44. 	}
    45. 	printf("\n");
    46. }
    47.  
    48. //双向链表头插
    49. void ListPushFront(ListNode* guard,LTDataType x)
    50. {
    51. 	assert(guard);
    52. 	/*ListNode* next = guard->next;
    53. 	struct ListNode* newnode = NodeCreate(x);
    54. 	guard->next = newnode;
    55. 	newnode->prev = guard;
    56. 	newnode->next = next;
    57. 	next->prev = newnode;*/
    58. 	//其实头插可以更简单
    59. 	ListInsert(guard->next,x);
    60. }
    61.  
    62. //链表尾插
    63. void ListPushBack(ListNode* guard, LTDataType x)
    64. {
    65. 	assert(guard);
    66. 	/*ListNode* newnode = NodeCreate(x);
    67. 	ListNode* tail = guard->prev;
    68. 	tail->next = newnode;
    69. 	newnode->prev = tail;
    70. 	newnode->next = guard;
    71. 	guard->prev = newnode;*/
    72. 	//其实尾插可以更简单
    73. 	ListInsert(guard, x);
    74. }
    75.  
    76. //链表头删
    77. void ListPopFront(ListNode* guard)
    78. {
    79. 	assert(guard);
    80. 	//万一链表中数据为空呢
    81.     //如果List是Empty，则返回true，！ListEmpty（guard）为0,断言就会生效
    82. 	assert(!ListEmpty(guard));
    83. 	//如果链表中除了guard就只有一个元素也没关系
    84. 	//最后guard自己指向自己
    85. 	ListNode* node = guard->next;
    86. 	ListNode* next = node->next;
    87. 	guard->next = next;
    88. 	next->prev = guard;
    89. 	free(node);
    90. 	node = NULL;//这只是在形式上改变了node，实际上是改变不了node的
    91. 	//头删也可以很简单
    92. 	/*ListErase(guard->next);*/
    93. }
    94.  
    95. //链表尾删
    96. void ListPopBack(ListNode* guard)
    97. {
    98. 	assert(guard);
    99. 	assert(!ListEmpty(guard));
    100. 	struct ListNode* tail = guard->prev;
    101. 	struct ListNode* prev = tail->prev;
    102. 	guard->prev = prev;
    103. 	prev->next = guard;
    104. 	free(tail);
    105. 	tail = NULL;
    106. 	//尾删也可以更简单
    107. 	//ListErase(guard->prev);
    108. }
    109.  
    110. //判断链表是否为空
    111. bool ListEmpty(ListNode* guard)
    112. {
    113. 	assert(guard);
    114. 	/*if (guard->next == guard)
    115. 	{
    116. 		return true;
    117. 	}
    118. 	else
    119. 		return false;*/
    120. 	//这个更简单,相等也就是说链表没有结点，就返回true，不相等就是链表中有节点，返回false
    121. 	return guard->next == guard;
    122. }
    123.  
    124. //链表长度
    125. //有人可能会疑惑，为什么不把数据存放在哨兵结点的data里面
    126. //因为LTDataType不确定，可能是char型，可能是int型，如果是char型
    127. //当结点数超过了128，char就达到上限了，就会出现问题
    128. size_t ListSize(ListNode* guard)
    129. {
    130. 	assert(guard);
    131. 	ListNode* cur = guard->next;
    132. 	size_t size = 0;
    133. 	while (cur != guard)
    134. 	{
    135. 		size++;
    136. 		cur = cur->next;
    137. 	}
    138. 	return  size;
    139. }
    140.  
    141. //链表查找
    142. ListNode* NodeFind(ListNode* guard, LTDataType x)
    143. {
    144. 	assert(guard);
    145. 	struct ListNode* cur = guard->next;
    146. 	while (cur != guard)
    147. 	{
    148. 		if (cur->val == x)
    149. 		{
    150. 			return cur;
    151. 		}
    152. 		cur = cur->next;
    153. 	}
    154. 	return NULL;
    155. }
    156.  
    157. //在pos的前面进行插入
    158. void ListInsert(ListNode* pos, LTDataType x)
    159. {
    160. 	assert(pos);
    161. 	struct ListNode* prev = pos->prev;
    162. 	struct ListNode* newnode = NodeCreate(x);
    163. 	prev->next = newnode;
    164. 	newnode->prev = prev;
    165. 	newnode->next = pos;
    166. 	pos->prev = newnode;
    167. }
    168.  
    169. //删除pos位置的结点
    170. void ListErase(ListNode* pos)
    171. {
    172. 	assert(pos);
    173. 	struct ListNode* prev = pos->prev;
    174. 	struct ListNode* next = pos->next;
    175. 	prev->next = next;
    176. 	next->prev = prev;
    177. 	free(pos);
    178. 	pos = NULL;
    179. }
    180.  
    181. //可以传二级，内部置空头结点
    182. // 建议：也可以考虑用一级指针，让调用ListDetory的人置空，保持接口的一致性
    183. //双向链表销毁
    184. void ListDestory(ListNode* guard)
    185. {
    186. 	assert(guard);
    187. 	//可不能一开始就把guard free掉了，不然就没有循环结束的判断条件了
    188. 	ListNode* cur = guard->next;
    189. 	while (cur!=guard)
    190. 	{
    191. 		ListNode* next = cur->next;
    192. 		free(cur);
    193. 		cur = next;
    194. 	}
    195. 	free(guard);
    196. }

     带头双向循环链表是链表中的最牛的存在，所以大家一定要学会这种结构的写法！

    好了，今天的博客就结束了，喜欢我的文章就点个赞再走吧！

  • 相关阅读:
    Grafana+Prometheus打造运维监控系统（一）-安装篇
    commitlint+husky+commitizen+lint-stage代码风格及上传规范管理
    python实现常用排序算法
    excel自定义函数之汉字转为拼音及大写字母
    解密Java多线程同步：掌握线程间同步与互斥技巧
    开学季哪些数码产品值得一看？开学季推荐五款值得入手的好物
    Android学习之路(20) 进程间通信
    实习记录--（海量数据如何判重？）--每天都要保持学习状态和专注的状态啊！！！---你的未来值得你去奋斗
    408操作系统知识点——第四章 文件管理
    Go 接口和多态
  • 原文地址：https://blog.csdn.net/yakiyakiya/article/details/126831471