devbox
Li_阴宅
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

数据结构——带头结点双向循环链表_双向循环链表的头指针为head,若带头结点,则表空的条件

作者：Li_阴宅 | 2024-07-06 19:43:05

赞

踩

双向循环链表的头指针为head,若带头结点,则表空的条件

相比较与单链表，双向循环链表每个结点多了一个prev指针域，用于指向该结点的前驱，并且链表的头尾结点也用指针域相连。所以对于带头结点的双向循环链表的判空条件为head->next=head;除此之外，双向循环链表的基本操作自然也与单链表有较大区别，接下来就让我们来逐步实现。

1.结构体定义

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

data为结点数据域，next指针指向当前结点的后继，prev指针指向当前结点的前驱。

2.基本操作实现

  1. //测试函数
  2. void Test_list();
  3. //双链表判空
  4. int ListEmpty(ListNode* pHead);
  5. //动态申请一个结点data；
  6. ListNode* buyDListNode(LTDataType data);
  7. // 创建返回链表的头结点.
  8. ListNode* ListCreate();
  9. // 双向链表销毁
  10. void ListDestory(ListNode* pHead);
  11. // 双向链表打印
  12. void ListPrint(ListNode* pHead);
  13. // 双向链表尾插
  14. void ListPushBack(ListNode* pHead, LTDataType x);
  15. // 双向链表尾删
  16. void ListPopBack(ListNode* pHead);
  17. // 双向链表头插
  18. void ListPushFront(ListNode* pHead, LTDataType x);
  19. // 双向链表头删
  20. void ListPopFront(ListNode* pHead);
  21. // 双向链表查找
  22. ListNode* ListFind(ListNode* pHead, LTDataType x);
  23. // 双向链表在pos的前面进行插入
  24. void ListInsert(ListNode* pos, LTDataType x);
  25. // 双向链表删除pos位置的节点
  26. void ListErase(ListNode* pos);

2.1动态申请结点

动态申请结点实现是后续实现链表的头结点创建和新结点插入的子功能，提前用函数封装好方便于后续操作函数的实现。具体实现：（1）通过malloc在堆上动态申请空间。（2）对新结点数据域对应赋值。（3）将结点前后指针域置空。

代码实现：

  1. ListNode* buyDListNode(LTDataType data) {//动态申请结点
  2. 	ListNode* newhead = (ListNode*)malloc(sizeof(ListNode));
  3. 	if (newhead == NULL) {//申请失败
  4. 		assert(0);
  5. 		return NULL;
  6. 	}
  7. 	newhead->data = data;
  8. 	newhead->next = NULL;
  9. 	newhead->prev = NULL;
  10. 	return newhead;
  11. }

2.2创建并返回链表头结点

通过动态申请结点函数创建头结点，头结点数据域初始化为0（或-1），初始状态下链表没有其余结点，所有将头结点的前后指针域都指向头结点本身。

代码实现：

  1. // 创建返回链表的头结点.
  2. ListNode* ListCreate() {
  3. 	ListNode* pHead = buyDListNode(0);
  4. 	pHead->next = pHead;
  5. 	pHead->prev = pHead;
  6. 	return pHead;
  7. }

2.3链表打印

通过简单循环便可实现：

  1. // 双向链表打印
  2. void ListPrint(ListNode* pHead) {
  3. 	assert(pHead);
  4. 	ListNode* cur = pHead->next;
  5. 	while (cur != pHead) {
  6. 		printf("%d ", cur->data);
  7. 		cur = cur->next;
  8. 	}
  9. 	printf("\n");
  10. }

2.4链表尾插

对于双向链表的插入，我们只需注意要先将结点连接进链表再断开插入位置前后结点的联系即可，

实现也是比较简单，可以通过画图辅助，过程更加清晰：

  1. // 双向链表尾插
  2. void ListPushBack(ListNode* pHead, LTDataType x) {
  3. 	ListNode* node = buyDListNode(x);
  4. 	//先不断开原链表，将新结点连接进去
  5. 	node->prev = pHead->prev;
  6. 	node->next = pHead;
  7. 	node->prev->next = node;
  8. 	pHead->prev = node;
  9. }

2.5链表头插

头插需注意的是是将结点插入在头结点之后，原理和尾插相同。

  1. void ListPushFront(ListNode* pHead, LTDataType x) {
  2. 	assert(pHead);
  3. 	ListNode* node = buyDListNode(x);
  4. 	//先不断开原链表，将新结点连接进去
  5. 	node->next = pHead->next;
  6. 	node->prev = pHead;
  7. 	pHead->next = node;
  8. 	node->next->prev = node;
  9. }

2.6链表任意位置插入

  1. // 双向链表在pos的前面进行插入
  2. void ListInsert(ListNode* pos, LTDataType x) {
  3. 	assert(pos);
  4. 	ListNode* node = buyDListNode(x);
  5. 	//先不断开原链表，将新结点连接进去
  6. 	node->next = pos;
  7. 	node->prev = pos->prev;
  8. 	node->prev->next = node;
  9. 	pos->prev = node;
  10. }

2.7链表删除

三种删除操作其操作也是相同的，只需理清结点指针域关系即可，通过画图即可清晰理清逻辑关系，所以这里直接给上代码：

  1. // 双向链表尾删
  2. void ListPopBack(ListNode* pHead) {
  3. 	assert(pHead);
  4. 	ListNode* delNode = NULL;
  5. 	if (ListEmpty(pHead)) {
  6. 		return;
  7. 	}
  8. 	delNode = pHead->prev;
  9. 	delNode->prev->next = pHead;
  10. 	pHead->prev = delNode->prev;
  11. 	free(delNode);
  12. }
  13. // 双向链表头删
  14. void ListPopFront(ListNode* pHead) {
  15. 	assert(pHead);
  16. 	if (ListEmpty(pHead)) {
  17. 		return;
  18. 	}
  19. 	ListNode* cur = pHead->next;
  20. 	pHead->next = pHead->next->next;
  21. 	pHead->next->prev = pHead;
  22. 	free(cur);
  23. }
  24. // 双向链表删除pos位置的节点
  25. void ListErase(ListNode* pos) {
  26. 	assert(pos);
  27. 	if (pos == NULL) {
  28. 		return;
  29. 	}
  30. 	ListNode* cur = pos;
  31. 	cur->prev->next = cur->next;
  32. 	cur->next->prev = cur->prev;
  33. 	free(cur);
  34. }

2.8链表查找

查找与打印主要都是遍历链表的过程，需注意的是循环条件不再是临时结点循环到NULL，而是结点遍历返回到头结点，即cur！=head:

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

2.9链表销毁

链表销毁只需遍历链表逐步释放结点即可，在释放结点之前需临时保存下个结点，以免后续结点丢失：

  1. // 双向链表销毁
  2. void ListDestory(ListNode* pHead) {
  3. 	assert(pHead);
  4. 	ListNode* head = pHead;
  5. 	ListNode* cur = head->next;
  6. 	while (cur != head) {
  7. 		ListNode* next = cur->next;
  8. 		free(cur);
  9. 		cur = next;
  10. 	}
  11. 	free(head);
  12. 	head = NULL;
  13. }

3.功能测试

  1. void Test_list() {
  2. 	ListNode* list = ListCreate();
  3.  
  4. 	ListPushBack(list, 2);
  5. 	ListPushBack(list, 3);
  6. 	ListPushBack(list, 4);
  7. 	ListPushBack(list, 5);
  8. 	ListPushFront(list, 1);
  9. 	ListPushFront(list, 0);
  10. 	ListPrint(list);
  11.  
  12. 	ListPopBack(list);
  13. 	ListPopBack(list);
  14. 	ListPopFront(list);
  15. 	ListPrint(list);
  16.  
  17. 	ListInsert(ListFind(list, 3), 99);
  18. 	ListPrint(list);
  19. 	ListErase(ListFind(list, 3));
  20. 	ListPrint(list);
  21.  
  22. 	ListDestory(list);
  23. }

测试结果：

4.完整代码

  1. #include<stdio.h>
  2. #include<assert.h>
  3. #include<malloc.h>
  4.  
  5. // 带头+双向+循环链表增删查改实现
  6. typedef int LTDataType;
  7. typedef struct ListNode
  8. {
  9. 	LTDataType data;
  10. 	struct ListNode* next;
  11. 	struct ListNode* prev;
  12. }ListNode;
  13.  
  14. //测试函数
  15. void Test_list();
  16. //双链表判空
  17. int ListEmpty(ListNode* pHead);
  18. //动态申请一个结点data；
  19. ListNode* buyDListNode(LTDataType data);
  20. // 创建返回链表的头结点.
  21. ListNode* ListCreate();
  22. // 双向链表销毁
  23. void ListDestory(ListNode* pHead);
  24. // 双向链表打印
  25. void ListPrint(ListNode* pHead);
  26. // 双向链表尾插
  27. void ListPushBack(ListNode* pHead, LTDataType x);
  28. // 双向链表尾删
  29. void ListPopBack(ListNode* pHead);
  30. // 双向链表头插
  31. void ListPushFront(ListNode* pHead, LTDataType x);
  32. // 双向链表头删
  33. void ListPopFront(ListNode* pHead);
  34. // 双向链表查找
  35. ListNode* ListFind(ListNode* pHead, LTDataType x);
  36. // 双向链表在pos的前面进行插入
  37. void ListInsert(ListNode* pos, LTDataType x);
  38. // 双向链表删除pos位置的节点
  39. void ListErase(ListNode* pos);
  40.  
  41. int main() {
  42. 	Test_list();
  43. 	return 0;
  44. }
  45.  
  46. void Test_list() {
  47. 	ListNode* list = ListCreate();
  48.  
  49. 	ListPushBack(list, 2);
  50. 	ListPushBack(list, 3);
  51. 	ListPushBack(list, 4);
  52. 	ListPushBack(list, 5);
  53. 	ListPushFront(list, 1);
  54. 	ListPushFront(list, 0);
  55. 	ListPrint(list);
  56.  
  57. 	ListPopBack(list);
  58. 	ListPopBack(list);
  59. 	ListPopFront(list);
  60. 	ListPrint(list);
  61.  
  62. 	ListInsert(ListFind(list, 3), 99);
  63. 	ListPrint(list);
  64. 	ListErase(ListFind(list, 3));
  65. 	ListPrint(list);
  66.  
  67. 	ListDestory(list);
  68. }
  69.  
  70. ListNode* buyDListNode(LTDataType data) {//动态申请结点
  71. 	ListNode* newhead = (ListNode*)malloc(sizeof(ListNode));
  72. 	if (newhead == NULL) {
  73. 		assert(0);
  74. 		return NULL;
  75. 	}
  76. 	newhead->data = data;
  77. 	newhead->next = NULL;
  78. 	newhead->prev = NULL;
  79. 	return newhead;
  80. }
  81.  
  82. // 创建返回链表的头结点.
  83. ListNode* ListCreate() {
  84. 	ListNode* pHead = buyDListNode(0);
  85. 	pHead->next = pHead;
  86. 	pHead->prev = pHead;
  87. 	return pHead;
  88. }
  89. // 双向链表销毁
  90. void ListDestory(ListNode* pHead) {
  91. 	assert(pHead);
  92. 	ListNode* head = pHead;
  93. 	ListNode* cur = head->next;
  94. 	while (cur != head) {
  95. 		ListNode* next = cur->next;
  96. 		free(cur);
  97. 		cur = next;
  98. 	}
  99. 	free(head);
  100. 	head = NULL;
  101. }
  102. // 双向链表打印
  103. void ListPrint(ListNode* pHead) {
  104. 	assert(pHead);
  105. 	ListNode* cur = pHead->next;
  106. 	while (cur != pHead) {
  107. 		printf("%d->", cur->data);
  108. 		cur = cur->next;
  109. 	}
  110. 	printf("NULL\n");
  111. }
  112. // 双向链表尾插
  113. void ListPushBack(ListNode* pHead, LTDataType x) {
  114. 	ListNode* node = buyDListNode(x);
  115. 	//先不断开原链表，将新结点连接进去
  116. 	node->prev = pHead->prev;
  117. 	node->next = pHead;
  118. 	node->prev->next = node;
  119. 	pHead->prev = node;
  120. }
  121. // 双向链表判空
  122. int ListEmpty(ListNode* pHead) {//判空，空返回1，非空返回0
  123. 	assert(pHead);
  124. 	return pHead->next == pHead;
  125. }
  126. // 双向链表尾删
  127. void ListPopBack(ListNode* pHead) {
  128. 	assert(pHead);
  129. 	ListNode* delNode = NULL;
  130. 	if (ListEmpty(pHead)) {
  131. 		return;
  132. 	}
  133. 	delNode = pHead->prev;
  134. 	delNode->prev->next = pHead;
  135. 	pHead->prev = delNode->prev;
  136. 	free(delNode);
  137. }
  138. // 双向链表头插
  139. void ListPushFront(ListNode* pHead, LTDataType x) {
  140. 	assert(pHead);
  141. 	ListNode* node = buyDListNode(x);
  142. 	//先不断开原链表，将新结点连接进去
  143. 	node->next = pHead->next;
  144. 	node->prev = pHead;
  145. 	pHead->next = node;
  146. 	node->next->prev = node;
  147. }
  148. // 双向链表头删
  149. void ListPopFront(ListNode* pHead) {
  150. 	assert(pHead);
  151. 	if (ListEmpty(pHead)) {
  152. 		return;
  153. 	}
  154. 	ListNode* cur = pHead->next;
  155. 	pHead->next = pHead->next->next;
  156. 	pHead->next->prev = pHead;
  157. 	free(cur);
  158. }
  159. // 双向链表查找
  160. ListNode* ListFind(ListNode* pHead, LTDataType x) {
  161. 	assert(pHead);
  162. 	if (ListEmpty(pHead)) {
  163. 		return NULL;
  164. 	}
  165. 	ListNode* cur = pHead->next;
  166. 	while (cur != pHead) {
  167. 		if (cur->data == x) {
  168. 			return cur;
  169. 		}
  170. 		cur = cur->next;
  171. 	}
  172. 	return NULL;
  173. }
  174. // 双向链表在pos的前面进行插入
  175. void ListInsert(ListNode* pos, LTDataType x) {
  176. 	assert(pos);
  177. 	ListNode* node = buyDListNode(x);
  178. 	//先不断开原链表，将新结点连接进去
  179. 	node->next = pos;
  180. 	node->prev = pos->prev;
  181. 	node->prev->next = node;
  182. 	pos->prev = node;
  183. }
  184. // 双向链表删除pos位置的节点
  185. void ListErase(ListNode* pos) {
  186. 	assert(pos);
  187. 	if (pos == NULL) {
  188. 		return;
  189. 	}
  190. 	ListNode* cur = pos;
  191. 	cur->prev->next = cur->next;
  192. 	cur->next->prev = cur->prev;
  193. 	free(cur);
  194. }

本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号