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

数据结构初阶--带头双向循环链表_带头指针的双循环链表

作者：weixin_40725706 | 2024-04-09 16:17:12

赞

踩

带头指针的双循环链表

目录

一.带头双向循环链表的定义

二.带头双向循环链表的功能实现

2.1.带头双向循环链表的定义

2.2.带头双向循环链表的结点创建

2.3.带头双向循环链表的初始化

2.4.带头双向循环链表的打印

2.5.带头双向循环链表的判空

2.6.带头双向循环链表的尾插

2.7.带头双向循环链表的头插

2.8.带头双向循环链表的尾删

2.9.带头双向循环链表的头删

2.10.带头双向循环链表的在pos位置之前插入

2.11.带头双向循环链表的删除pos位置的结点

2.12.带头双向循环链表的求链表长度

2.13.带头双向循环链表的销毁

2.14.完整程序

List.h

List.c

test.c

三. 顺序表和链表的比较

逻辑结构

存储结构

基本操作

创建

销毁

增加与删除

查找

一.带头双向循环链表的定义

循环单链表虽然能够实现从任一结点出发沿着链能找到其前驱结点，但时间耗费是O(n)。如果希望从表中快速确定某一个结点的前驱，另一个解决方法就是在单链表的每个结点里再增加一个指向其前驱的指针域prior。这样形成的链表中就有两条方向不同的链，称之为双(向)链表。

与单链表类似，双链表也可增加头结点使双链表的某些运算变得方便。同时双向链表也可以有循环表，称为双向循环链表。

由于在双向链表中既有前向链又有后向链，寻找任一结点的直接前驱结点与直接后继结点都变得非常方便了。

二.带头双向循环链表的功能实现

2.1.带头双向循环链表的定义

  1. //定义
  2. typedef int LTDataType;
  3.  
  4. typedef struct ListNode
  5. {
  6. 	struct ListNode* next;
  7. 	struct ListNode* pre;
  8. 	LTDataType data;
  9. }LTNode;

 与单链表的定义不同，带头双向循环链表要定义两个指针：前驱指针pre和后继指针next。前驱指针pre用于指向当前结点的上一个结点，后继指针next用于指向当前结点的下一个结点。

2.2.带头双向循环链表的结点创建

  1. LTNode* BuyListNode(LTDataType x)
  2. {
  3. 	//动态开辟一个结点node
  4. 	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
  5.  
  6. 	//判空
  7. 	if (node == NULL)
  8. 	{
  9. 		perror("malloc fail!");
  10. 		exit(-1);
  11. 	}
  12.  
  13. 	//前驱与后继结点均置为空
  14. 	node->data = x;
  15. 	node->next = NULL;
  16. 	node->pre = NULL;
  17.  
  18. 	return node;
  19. }

结点的创建主要是通过调用malloc函数来实现，初始化时要将前驱指针和后继指针都置为NULL。

2.3.带头双向循环链表的初始化

版本一：

  1. void ListInit(LTNode** phead)
  2. {
  3. 	//这里需要传入二级指针，即传地址，才能实现对链表的修改
  4.  
  5. 	//判空
  6. 	assert(phead);
  7. 	
  8. 	//创建头结点
  9. 	*phead = BuyListNode(-1);
  10.  
  11. 	//将头结点的前驱指针和后继指针均指向自身
  12. 	(*phead)->next = *phead;
  13. 	(*phead)->pre = *phead;
  14. }

版本二：

  1. LTNode* ListInit()
  2. {
  3. 	//创建头结点
  4. 	LTNode* phead = BuyListNode(-1);
  5.  
  6. 	//将头结点的前驱指针和后继指针均指向自身
  7. 	phead->next = phead;
  8. 	phead->pre = phead;
  9.  
  10. 	//返回头结点
  11. 	return phead;
  12. }

链表的初始化采用了两种方式：传二级指针和设置返回值。

总结：

如果要改变头指针，就要传二级指针。不需要改变头指针的话，则传入一级指针。

在使用带头结点的单链表时：

  1. 初始化链表头指针需要传二级指针；
  2. 销毁链表需要传二级指针；
  3. 插入、删除、遍历、清空结点用一级指针即可。

不带头结点的单链表，除了初始化和销毁，插入、删除和清空结点也需要二级指针。

调试分析：

2.4.带头双向循环链表的打印

  1. void ListPrint(LTNode* phead)
  2. {
  3. 	//判空
  4. 	assert(phead);
  5.  
  6. 	//cur指向链表的第一个结点
  7. 	LTNode* cur = phead->next;
  8.  
  9. 	//cur依次向后遍历，直到cur重新回到头结点
  10. 	while (cur != phead)
  11. 	{
  12. 		printf("%d ", cur->data);
  13. 		cur = cur->next;
  14. 	}
  15.  
  16. 	printf("\n");
  17. }

设置一个临时变量cur，指向当前链表的第一个结点(非头结点)，然后依次向后遍历该链表，直到cur重新回到头结点phead的位置。

2.5.带头双向循环链表的判空

  1. bool ListEmpty(LTNode* phead)
  2. {
  3. 	//判空
  4. 	assert(phead);
  5.  
  6. 	//如果phead->next等于phead，则链表为空，返回true
  7. 	//如果phead->next不等于phead，则链表不为空，返回false
  8. 	return phead->next == phead;
  9. }

如果phead->next等于phead，则链表为空，返回true；如果phead->next不等于phead，则链表不为空，返回false。

2.6.带头双向循环链表的尾插

  1. void ListPushBack(LTNode* phead, LTDataType x)
  2. {
  3. 	//判空
  4. 	assert(phead);
  5.  
  6. 	//创建新结点
  7. 	LTNode* newnode = BuyListNode(x);
  8.  
  9. 	//查找尾结点
  10. 	LTNode* tail = phead->pre;
  11.  
  12. 	//尾插
  13. 	//原尾和新尾相互链接
  14. 	tail->next = newnode;
  15. 	newnode->pre = tail;
  16. 	//头结点和新尾相互链接
  17. 	newnode->next = phead;
  18. 	phead->pre = newnode;
  19. }

相较于单链表的尾插，带头双向循环链表的尾插不需要从头结点开始依次向后遍历，因为头结点的前驱结点便指向尾结点tail。在找到尾结点tail之后，便可将新结点newnode插入到尾结点tail的后面。此时newnode变为新的尾结点。

调试分析：

运行结果：

2.7.带头双向循环链表的头插

  1. void ListPushFront(LTNode* phead, LTDataType x)
  2. {
  3. 	//判空
  4. 	assert(phead);
  5.  
  6. 	//创建新结点
  7. 	LTNode* newnode = BuyListNode(x);
  8.  
  9. 	//头插
  10. 	//phead newnode next：三者不分先后顺序
  11. 	//法一：
  12. 	LTNode* next = phead->next;
  13. 	phead->next = newnode;
  14. 	newnode->pre = phead;
  15. 	newnode->next = next;
  16. 	next->pre = newnode;
  17.  
  18. 	//phead newnode phead->next：先处理后两个，再处理前两个
  19.     //法二：
  20. 	//phead->next->pre = newnode;
  21. 	//newnode->next = phead->next;
  22. 	//phead->next = newnode;
  23. 	//newnode->pre = phead;
  24. }

在进行头插时，要注意结点之间插入的先后顺序，这里主要介绍两种方式。方式一：创建一个临时变量next，然后将头结点的下一个结点保存在next当中。首先调用BuyListNode(x)创建一个新结点newnode，然后将phead，newnode和next三个结点进行链接。三个结点不分先后顺序，直接进行链接即可。该方式最为简单，也最不容易出错；方式二：不创建临时变量next。首先调用BuyListNode(x)创建一个新结点newnode，然后将phead，newnode和phead->next三个结点进行链接。链接是关键：要先将后两个结点进行链接，然后再将前两个结点进行链接。三个结点一定要注意先后顺序，不可随意链接。

调试分析：

运行结果：

2.8.带头双向循环链表的尾删

  1. void ListPopBack(LTNode* phead)
  2. {
  3. 	//判空
  4. 	assert(phead);
  5.  
  6. 	//判断链表是否为空
  7. 	assert(phead->next != phead);
  8. 	//assert(!ListEmpty(phead));
  9.  
  10. 	//找尾结点
  11. 	LTNode* tail = phead->pre;
  12.  
  13. 	//找尾结点的前一结点
  14. 	LTNode* tailPre = tail->pre;
  15.  
  16. 	//释放尾结点
  17. 	free(tail);
  18.  
  19. 	tailPre->next = phead;
  20. 	phead->pre = tailPre;
  21. }

在进行尾删之前，首先要判断链表是否为空，可以通过phead->next != phead进行判断，也可以调用ListEmpty(phead)函数进行判断；然后找到链表的尾结点tail，以及链表尾结点的前一个结点tailPre；接着调用free函数释放尾结点tail，并将tailPre作为新的尾结点；最后再将新的尾结点与头结点phead进行相连即可。

调试分析：

运行结果：

2.9.带头双向循环链表的头删

  1. void ListPopFront(LTNode* phead)
  2. {
  3. 	//判空
  4. 	assert(phead);
  5.  
  6. 	//判断链表是否为空
  7. 	assert(phead->next != phead);
  8. 	//assert(!ListEmpty(phead));
  9.  
  10. 	//tail记录第一个结点之后的下一个结点
  11. 	LTNode* tail = phead->next->next;
  12. 	
  13. 	//释放第一个结点
  14. 	free(phead->next);
  15.  
  16. 	//将头结点和tail相链接
  17. 	phead->next = tail;
  18. 	tail->pre = phead;
  19. }

在进行头删之前，首先要判断链表是否为空，可以通过phead->next != phead进行判断，也可以调用ListEmpty(phead)函数进行判断；然后找到链表的第二个有效结点tail；接着调用free函数释放掉第一个有效结点，并将tail作为新的第一个有效结点；最后再将新的第一个结点tail与头结点phead进行相连即可。

调试分析：

运行结果：

2.10.带头双向循环链表的在pos位置之前插入

  1. void ListInsert(LTNode* pos, LTDataType x)
  2. {
  3. 	//判空
  4. 	assert(pos);
  5.  
  6. 	//查找pos的前一个结点
  7. 	LTNode* pre = pos->pre;
  8.  
  9. 	//创建新结点
  10. 	LTNode* newnode = BuyListNode(x);
  11.  
  12. 	//pre newnode pos
  13. 	pre->next = newnode;
  14. 	newnode->pre = pre;
  15. 	newnode->next = pos;
  16. 	pos->pre = newnode;
  17. }

给定一个结点pos，如果是带头双向循环链表，那么pos之前的结点和pos之后的结点都是可知的。要在pos位置之前插入，首先要找到pos的前一结点pre，然后调用BuyListNode(x)创建一个新结点newnode，接着将pre，newnode和pos三个结点进行链接即可。此时pos位置的结点将由pos变为newnode。

调试分析：

运行结果：

2.11.带头双向循环链表的删除pos位置的结点

  1. void ListErase(LTNode* pos)
  2. {
  3. 	//判空
  4. 	assert(pos);
  5.  
  6. 	//查找pos的前一个结点
  7. 	LTNode* pre = pos->pre;
  8. 	
  9. 	//查找pos的后一个结点
  10. 	LTNode* next = pos->next;
  11.  
  12. 	//将前一个结点pre与后一个结点next相链接
  13. 	pre->next = next;
  14. 	next->pre = pre;
  15.  
  16. 	//释放pos结点
  17. 	free(pos);
  18. }

在删除pos位置的结点之前，首先要找到pos位置的前一个结点pre，然后找到pos位置的后一个结点next，接着将结点pre与next相链接，最后再调用free函数释放掉pos结点即可。

调试分析：

运行结果：

2.12.带头双向循环链表的求链表长度

  1. int ListSize(LTNode* phead)
  2. {
  3. 	//判空
  4. 	assert(phead);
  5.  
  6. 	//cur指向当前链表的第一个结点
  7. 	LTNode* cur = phead->next;
  8. 	
  9. 	//用于记录遍历过的结点数
  10. 	int size = 0;
  11.  
  12. 	//从第一个结点开始依次向后遍历，直到遍历到头结点
  13. 	while (cur != phead)
  14. 	{
  15. 		++size;
  16. 		cur = cur->next;
  17. 	}
  18.  
  19. 	return size;
  20. }

调试分析：

运行结果：

2.13.带头双向循环链表的销毁

  1. void ListDestory(LTNode* phead)
  2. {
  3. 	//判空
  4. 	assert(phead);
  5.  
  6. 	//cur指向当前第一个结点
  7. 	LTNode* cur = phead->next;
  8.  
  9. 	while (cur != phead)
  10. 	{
  11. 		//保存cur的下一个结点
  12. 		LTNode* next = cur->next;
  13.  
  14. 		//删除cur
  15. 		ListErase(cur);
  16.  
  17. 		//更新cur
  18. 		cur = next;
  19. 	}
  20.  
  21. 	//释放头结点
  22. 	free(phead);
  23. }

调试分析：

运行结果：

2.14.完整程序

List.h

  1. #pragma once
  2.  
  3. #include<stdio.h>
  4. #include<stdlib.h>
  5. #include<assert.h>
  6. #include<stdbool.h>
  7.  
  8. //带头双向循环链表
  9.  
  10. //定义
  11. typedef int LTDataType;
  12.  
  13. typedef struct ListNode
  14. {
  15. 	struct ListNode* next;
  16. 	struct ListNode* pre;
  17. 	LTDataType data;
  18. }LTNode;
  19.  
  20. //创建结点
  21. LTNode* BuyListNode(LTDataType x);
  22.  
  23. //初始化：版本一
  24. //void ListInit(LTNode** phead);
  25.  
  26. //初始化：版本二
  27. LTNode* ListInit();
  28.  
  29. //打印
  30. void ListPrint(LTNode* phead);
  31.  
  32. //判空
  33. bool ListEmpty(LTNode* phead);
  34.  
  35. //尾插
  36. //不用二级指针的原因：尾插时不会改变phead，因为它带哨兵位，尾插时不会对哨兵位进行修改
  37. void ListPushBack(LTNode* phead, LTDataType x);
  38.  
  39. //头插
  40. void ListPushFront(LTNode* phead, LTDataType x);
  41.  
  42. //尾删
  43. void ListPopBack(LTNode* phead);
  44.  
  45. //头删
  46. void ListPopFront(LTNode* phead);
  47.  
  48. //在pos位置之前插入
  49. void ListInsert(LTNode* pos, LTDataType x);
  50.  
  51. //删除pos位置的结点
  52. void ListErase(LTNode* pos);
  53.  
  54. //链表长度
  55. int ListSize(LTNode* phead);
  56.  
  57. //销毁
  58. void ListDestory(LTNode* phead);

List.c

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2.  
  3.  
  4. #include"List.h"
  5.  
  6.  
  7. //创建结点
  8. LTNode* BuyListNode(LTDataType x)
  9. {
  10. 	//动态开辟一个结点node
  11. 	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
  12.  
  13. 	//判空
  14. 	if (node == NULL)
  15. 	{
  16. 		perror("malloc fail!");
  17. 		exit(-1);
  18. 	}
  19.  
  20. 	//前驱与后继结点均置为空
  21. 	node->data = x;
  22. 	node->next = NULL;
  23. 	node->pre = NULL;
  24.  
  25. 	return node;
  26. }
  27.  
  28.  
  29. //初始化
  30. /*
  31. void ListInit(LTNode** phead)
  32. {
  33. 	//这里需要传入二级指针，即传地址，才能实现对链表的修改
  35. 	//判空
  36. 	assert(phead);
  37. 	
  38. 	//创建头结点
  39. 	*phead = BuyListNode(-1);
  41. 	//将头结点的前驱指针和后继指针均指向自身
  42. 	(*phead)->next = *phead;
  43. 	(*phead)->pre = *phead;
  44. }
  45. */
  46.  
  47.  
  48. //初始化
  49. LTNode* ListInit()
  50. {
  51. 	//创建头结点
  52. 	LTNode* phead = BuyListNode(-1);
  53.  
  54. 	//将头结点的前驱指针和后继指针均指向自身
  55. 	phead->next = phead;
  56. 	phead->pre = phead;
  57.  
  58. 	//返回头结点
  59. 	return phead;
  60. }
  61.  
  62.  
  63. //打印
  64. void ListPrint(LTNode* phead)
  65. {
  66. 	//判空
  67. 	assert(phead);
  68.  
  69. 	//cur指向链表的第一个结点
  70. 	LTNode* cur = phead->next;
  71.  
  72. 	//cur依次向后遍历，直到cur重新回到头结点
  73. 	while (cur != phead)
  74. 	{
  75. 		printf("%d ", cur->data);
  76. 		cur = cur->next;
  77. 	}
  78.  
  79. 	printf("\n");
  80. }
  81.  
  82.  
  83. //判空
  84. bool ListEmpty(LTNode* phead)
  85. {
  86. 	//判空
  87. 	assert(phead);
  88.  
  89. 	//如果phead->next等于phead，则链表为空，返回true
  90. 	//如果phead->next不等于phead，则链表不为空，返回false
  91. 	return phead->next == phead;
  92. }
  93.  
  94.  
  95. //尾插
  96. void ListPushBack(LTNode* phead, LTDataType x)
  97. {
  98. 	//判空
  99. 	assert(phead);
  100.  
  101. 	/*
  102. 	//创建新结点
  103. 	LTNode* newnode = BuyListNode(x);
  105. 	//查找尾结点
  106. 	LTNode* tail = phead->pre;
  108. 	//尾插
  109. 	//原尾和新尾相互链接
  110. 	tail->next = newnode;
  111. 	newnode->pre = tail;
  112. 	//头结点和新尾相互链接
  113. 	newnode->next = phead;
  114. 	phead->pre = newnode;
  115. 	*/
  116.  
  117. 	//尾插
  118. 	ListInsert(phead, x);//是phead而不是phead->pre
  119. }
  120.  
  121.  
  122. //头插
  123. void ListPushFront(LTNode* phead, LTDataType x)
  124. {
  125. 	//判空
  126. 	assert(phead);
  127.  
  128. 	/*
  129. 	//创建新结点
  130. 	LTNode* newnode = BuyListNode(x);
  132. 	//头插
  133. 	//phead newnode next：三者不分先后顺序
  134. 	//法一：
  135. 	LTNode* next = phead->next;
  136. 	phead->next = newnode;
  137. 	newnode->pre = phead;
  138. 	newnode->next = next;
  139. 	next->pre = newnode;
  141. 	//phead newnode phead->next：先处理后两个，再处理前两个
  142.     //法二：
  143. 	//phead->next->pre = newnode;
  144. 	//newnode->next = phead->next;
  145. 	//phead->next = newnode;
  146. 	//newnode->pre = phead;
  147. 	*/
  148.  
  149. 	//头插
  150. 	ListInsert(phead->next, x);
  151. }
  152.  
  153.  
  154. //尾删
  155. void ListPopBack(LTNode* phead)
  156. {
  157. 	//判空
  158. 	assert(phead);
  159.  
  160. 	//判断链表是否为空
  161. 	assert(phead->next != phead);
  162. 	//assert(!ListEmpty(phead));
  163.  
  164. 	/*
  165. 	//找尾结点
  166. 	LTNode* tail = phead->pre;
  168. 	//找尾结点的前一结点
  169. 	LTNode* tailPre = tail->pre;
  171. 	//释放尾结点
  172. 	free(tail);
  174. 	tailPre->next = phead;
  175. 	phead->pre = tailPre;
  176. 	*/
  177.  
  178. 	//尾删
  179. 	ListErase(phead->pre);
  180. }
  181.  
  182.  
  183. //头删
  184. void ListPopFront(LTNode* phead)
  185. {
  186. 	//判空
  187. 	assert(phead);
  188.  
  189. 	//判断链表是否为空
  190. 	assert(phead->next != phead);
  191. 	//assert(!ListEmpty(phead));
  192.  
  193. 	/*
  194. 	//tail记录第一个结点之后的下一个结点
  195. 	LTNode* tail = phead->next->next;
  196. 	
  197. 	//释放第一个结点
  198. 	free(phead->next);
  200. 	//将头结点和tail相链接
  201. 	phead->next = tail;
  202. 	tail->pre = phead;
  203. 	*/
  204.  
  205. 	//头删
  206. 	ListErase(phead->next);
  207. }
  208.  
  209.  
  210. //在pos位置之前插入x
  211. void ListInsert(LTNode* pos, LTDataType x)
  212. {
  213. 	//判空
  214. 	assert(pos);
  215.  
  216. 	//查找pos的前一个结点
  217. 	LTNode* pre = pos->pre;
  218.  
  219. 	//创建新结点
  220. 	LTNode* newnode = BuyListNode(x);
  221.  
  222. 	//pre newnode pos
  223. 	pre->next = newnode;
  224. 	newnode->pre = pre;
  225. 	newnode->next = pos;
  226. 	pos->pre = newnode;
  227. }
  228.  
  229.  
  230. //删除pos位置的结点
  231. void ListErase(LTNode* pos)
  232. {
  233. 	//判空
  234. 	assert(pos);
  235.  
  236. 	//查找pos的前一个结点
  237. 	LTNode* pre = pos->pre;
  238. 	
  239. 	//查找pos的后一个结点
  240. 	LTNode* next = pos->next;
  241.  
  242. 	//将前一个结点pre与后一个结点next相链接
  243. 	pre->next = next;
  244. 	next->pre = pre;
  245.  
  246. 	//释放pos结点
  247. 	free(pos);
  248. }
  249.  
  250.  
  251. //链表长度
  252. int ListSize(LTNode* phead)
  253. {
  254. 	//判空
  255. 	assert(phead);
  256.  
  257. 	//cur指向当前链表的第一个结点
  258. 	LTNode* cur = phead->next;
  259. 	
  260. 	//用于记录遍历过的结点数
  261. 	int size = 0;
  262.  
  263. 	//从第一个结点开始依次向后遍历，直到遍历到头结点
  264. 	while (cur != phead)
  265. 	{
  266. 		++size;
  267. 		cur = cur->next;
  268. 	}
  269.  
  270. 	return size;
  271. }
  272.  
  273.  
  274. //销毁
  275. void ListDestory(LTNode* phead)
  276. {
  277. 	//判空
  278. 	assert(phead);
  279.  
  280. 	//cur指向当前第一个结点
  281. 	LTNode* cur = phead->next;
  282.  
  283. 	while (cur != phead)
  284. 	{
  285. 		//保存cur的下一个结点
  286. 		LTNode* next = cur->next;
  287.  
  288. 		//法一：删除cur
  289. 		//ListErase(cur);
  290. 		
  291. 		//法二：删除cur
  292. 		free(cur);
  293.  
  294. 		//更新cur
  295. 		cur = next;
  296. 	}
  297.  
  298. 	//释放头结点
  299. 	free(phead);
  300. }

test.c

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2.  
  3. #include"List.h"
  4.  
  5. void test()
  6. {
  7. 	LTNode* plist = NULL;
  8.  
  9. 	//初始化
  10. 	plist = ListInit();
  11.  
  12. 	//头插
  13. 	ListPushFront(plist, 1);
  14. 	ListPushFront(plist, 2);
  15. 	ListPushFront(plist, 3);
  16. 	ListPushFront(plist, 4);
  17. 	ListPushFront(plist, 5);
  18. 	ListPrint(plist);
  19.  
  20. 	ListDestory(plist);
  21. 	ListPrint(plist);
  22. }
  23.  
  24. int main()
  25. {
  26. 	test();
  27.  
  28. 	return 0;
  29. }

三. 顺序表和链表的比较

下面分别从逻辑结构，存储结构，基本操作的角度对顺序表和链表进行比较。

逻辑结构

都属于线性表，都是线性结构。

存储结构

基本操作

对于任何一个数据结构，基本操作基本都能归纳为创销，增删改查。其中改建立在查的基础上。

创建

销毁

增加与删除

查找

用链表还是顺序表

          顺序表          链表
弹性（可扩容）             ×           √
     增，删             ×           √
        改             √           ×

表长难以预估，经常需要增加/删除元素--链表

表长可预估，查询（搜索）操作较多--顺序表

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/393890
推荐阅读
相关标签

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

  

闽ICP备14008679号