• 链表（2）——带头双向循环链表

    目录

    🍁一、链表的分类

    🌕1.单向或者双向

    🌕2.带头或者不带头（有无哨兵）

    🌕3.循环或者不循环

    🌕4.无头单向非循环链表（常用）

    🌕5.带头双向循环链表（常用）

    🌕注意：

    🍁二、双向链表的定义：

    🍁三、带头双向循环链表的定义

    🍁四、带头双向循环链表操作实现（多文件）

    🌕1.定义：

    🌕2.获得新结点

    🌕3.初始化

    🌕4.尾插法

    2.1：优势

    2.2：尾插法大致分为“四步骤”：

    2.3:源代码

    🌕5.打印数据

    🌕6.尾删法

    6.1：相对于单链表，该链表也有几个优点：

    6.2：尾删步骤：

    6.3：源代码：

    🌕7.头插法

    7.1：四步骤：

    7.2：源代码

    🌕8.头删法

    8.1：步骤

    8.2:源代码

    🌕9.在pos位置之前插入结点

    9.1：源代码如下：

    9.2：有了这个算法后我们可以改进头插与尾插：

    🌕10.删除pos位置的结点

    10.1：步骤：

    10.2：源代码

    10.3：有了这个算法，我们可以改进头删与尾删

    🍁五、测试源代码

    main.c

    List.c

    List.h

    🍁一、链表的分类

    🌕1.单向或者双向

    🌕2.带头或者不带头（有无哨兵）

    🌕3.循环或者不循环

    🌕4.无头单向非循环链表（常用）

    🌕5.带头双向循环链表（常用）

    🌕注意：

    1. 无头单向非循环链表： 结构简单 ，一般不会单独用来存数据。实际中更多是作为 其他数据结 构的子结构 ，如哈希桶、图的邻接表等等。另外这种结构在 笔试面试 中出现很多。
    2. 带头双向循环链表： 结构最复杂 ，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们代码实现了就知道了。

    🍁二、双向链表的定义：

    我们知道单链表的结点有一个数据域用于存放数据，一个指针域用于指向下一个结点。而 双向链表即是在此基础上每个结点多了一个指针域用于指向前一个结点；

    🍁三、带头双向循环链表的定义

    带头双向循环链表：即在双向链表的基础上，尾结点的next域指向头结点，使之体现出一个循环的结构。

    🍁四、带头双向循环链表操作实现（多文件）

    🌕1.定义：

    只需在单链表定义的基础上多一个指针域prve，用于指向前驱；

    1. typedef int SLDataType;
    2.  
    3. typedef struct ListNode
    4. {
    5. 	struct ListNode* prev;//指向前驱
    6. 	struct ListNode* next;//指向后继
    7. 	SLDataType data;//数据域
    8. }ListNode;

    🌕2.获得新结点

    因为后续经常用到此函数，所以首先介绍。

    操作很简单，用malloc函数生成即可

    1. //获得新结点
    2. ListNode* BuyLTNode(SLDataType x)
    3. {
    4. 	//用malloc函数动态生成即可
    5. 	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
    6. 	if (node == NULL)
    7. 	{
    8. 		//检查malloc错误原因
    9. 		perror("malloc");
    10. 		exit(-1);
    11. 	}
    12. 	//处理新结点的成员
    13. 	node->data = x;
    14. 	node->next = NULL;
    15. 	node->prev = NULL;
    16. 	return node;
    17. }

    🌕3.初始化

    ①：原本初始化需要改变头结点phead，所以需要结构体二级指针，但其他操作都不需要二级指针，所以为了排面，我们可以用返回值来代替使用二级指针；

    ②：初始化只需要获得一个新结点作为一个头结点，然后头结点的两个指针域互相指向代表此时为空表；

    1. //初始化
    2. ListNode* Init()
    3. {
    4. 	//获得头结点，头结点数据域可以存点有意义的数据，也可以随便存，因为用不着
    5. 	ListNode* phead = BuyLTNode(0);
    6. 	//初始化头结点的两个指针域指向头结点本身表示为空表
    7. 	phead->next = phead;
    8. 	phead->prev = phead;
    9. 	return phead;
    10. }

    🌕4.尾插法

    该种类链表虽然结构复杂，但操作却非常简单，比如尾插法就有几点优势于单链表；

    2.1：优势

    ①：单链表尾插需要考虑元素是否为空，当链表中没有元素时会改变头指针（头结点），所以需要使用结构体二级指针；但带头双向循环链表因为带有头，所以不管有无元素，在尾插时只需改变结构体指针域，即改变结构体，所以都只需要使用结构体指针；

    ②：单链表尾插时需要找到尾结点，但带头双向循环链表不需要，因为多了一个prev指针域，头结点的prev域就是尾结点；可以参考上述图片；

    2.2：尾插法大致分为“四步骤”：

    首先创建一个临时指针tail指向头结点的prev域，即指向尾结点便于操作

    ①：将tail的next域指向新结点；

    ②：将新结点的prev域指向tail结点（尾结点）;

    ③：将新结点的next域指向头结点；

    ④：将头结点的prev域指向新结点。

    2.3:源代码
    1. //尾插
    2. //因为带有头，所以操作只需要改变结构体，所以只需要结构体指针
    3. //具体操作看注释
    4. void LTPushBack(ListNode* phead, SLDataType x)
    5. {
    6. 	//因为是带头的，所以phead至少是个头指针，所以phead不可能为空，所以需要用assert检查一下
    7. 	assert(phead);
    8. 	//找到尾结点tail
    9. 	ListNode* tail = phead->prev;
    10. 	//获取新结点newnode
    11. 	ListNode* newnode = BuyLTNode(x);
    12. 	//四步骤
    13. 	tail->next = newnode;
    14. 	newnode->prev = tail;
    15. 	phead->prev = newnode;
    16. 	newnode->next = phead;
    17. }

    🌕5.打印数据

    此链表打印数据与单链表有一个区别，就是结束条件不同；因为带头双向循环链表的尾结点的next域不指向NULL，而是指向头结点，所以结束条件为“tail==head”;

    1. //打印
    2. void LTprint(ListNode* phead)
    3. {
    4. 	//创建一个临时指针便于遍历操作
    5. 	ListNode* node = phead->next;
    6. 	//为了体现此链表结构而打印
    7. 	printf("phead<->");
    8. 	//打印数据,当临时指针node等于头结点时结束
    9. 	while (node != phead)
    10. 	{
    11. 		printf("%d<->", node->data);
    12. 		node = node->next;
    13. 	}
    14. 	//为了体现此链表结构而打印
    15. 	printf("phead\n");
    16. }

    🌕6.尾删法

    6.1：相对于单链表，该链表也有几个优点：

    ①：尾删不用找尾结点以及倒数第二个结点，用prev域就可以找到；

    ②：当表中只有一个元素时，单链表需要改变结构体指针，所以需要单独分类；而此链表因为有带头结点和prev域，所以用正常尾删方法即可；

    6.2：尾删步骤：

    ①：判断单链表是否为空（条件：phead->next=phead时即为空）；

    ②：创建一个临时指针tail1用于保存尾结点，方便后续释放尾结点；

    ③：创建一个临时指针tail2用于保存尾结点的prev域（尾结点的前一个结点），方便进行尾删操作；

    ④：tail2的next域指向头结点：tail2->next=phead;

    ⑤：头结点的prev域指向tail2结点：phead->prev=tail2;

    ⑥:释放尾结点tail1。

    6.3：源代码：
    1.  
    2. //尾删
    3. void LTPopBack(ListNode* phead)
    4. {
    5. 	assert(phead);
    6. 	//检查是否为空
    7. 	if (phead->next == phead)
    8. 	{
    9. 		printf("此链表为空，尾删失败！\n");
    10. 		return;
    11. 	}
    12. 	//临时指针保存结点
    13. 	ListNode* tail1 = phead->prev;
    14. 	ListNode* tail2 = phead->prev->prev;
    15. 	//断开与尾结点的链接
    16. 	tail2->next = phead;
    17. 	phead->prev = tail2;
    18. 	//释放尾结点
    19. 	free(tail1);
    20. }

    🌕7.头插法

    同上，因为prev的存在，所以不用考虑初始表是否为空表的情况；

    7.1：四步骤：

    ①：新结点的next域指向head的next域（即指向插入前的首结点）；

    ②：head的next域的prev域指向新结点（即插入前的首结点的prev域指向新结点）；

    ③：新结点的prev域指向头结点head；

    ④：头结点head的next域指向新结点。

    7.2：源代码
    1. //头插
    2. void LTPushFront(ListNode* phead, SLDataType x)
    3. {
    4. 	assert(phead);
    5. 	//新结点
    6. 	ListNode* newnode = BuyLTNode(x);
    7. 	//四步骤
    8. 	newnode->next = phead->next;
    9. 	phead->next->prev = newnode;
    10. 	newnode->prev = phead;
    11. 	phead->next = newnode;
    12. }

    🌕8.头删法

    头删法也很简单，只需考虑个个指针的链接即可；

    8.1：步骤

    ①：创建临时指针first指向首结点，便于后续释放首结点；

    ②：创建临时指针second指向第二个结点，便于进行删除操作；

    ③：改变指针链接：

    second->prev = phead;

    phead->next = second;

    ④：释放首结点；

    8.2:源代码
    1. //头删
    2. void LTPopFront(ListNode* phead)
    3. {
    4. 	assert(phead);
    5. 	if (phead->next == phead)
    6. 	{
    7. 		printf("链表为空，头删失败！\n");
    8. 		return;
    9. 	}
    10. 	//临时指针first指向首结点，便于后续释放首结点
    11. 	//临时指针second指向第二个结点，便于进行删除操作
    12. 	ListNode* first = phead->next;
    13. 	ListNode* second = first->next;
    14. 	//删除
    15. 	second->prev = phead;
    16. 	phead->next = second;
    17. 	//释放首结点
    18. 	free(first);
    19. }

    🌕9.在pos位置之前插入结点

    其实很简单，只需要搞得指针域的链接顺序，防止指针丢失即可

    9.1：源代码如下：
     
    1. //在pos位置之前插入结点
    2. ListNode* LTInsrt(ListNode* pos, SLDataType x)
    3. {
    4. 	assert(pos);
    5. 	//新结点
    6. 	ListNode* newnode = BuyLTNode(x);
    7. 	//插入
    8. 	pos->prev->next = newnode;
    9. 	newnode->prev = pos->prev;
    10. 	newnode->next = pos;
    11. 	pos->prev = newnode;
    12. }
    9.2：有了这个算法后我们可以改进头插与尾插：

    ①：当pos==phead->next时，即为头插算法：
     

    1. //头插
    2. void LTPushFront(ListNode* phead, SLDataType x)
    3. {
    4. 	assert(phead);
    5.  
    6. 	//改进
    7. 	LTInsrt(phead->next, x);
    8. }

    ②：当pos等于phead时，即为尾插算法：

    1. //尾插
    2. void LTPushBack(ListNode* phead, SLDataType x)
    3. {
    4. 	//因为是带头的，所以phead至少是个头指针，所以phead不可能为空，所以需要用assert检查一下
    5. 	assert(phead);
    6.  
    7. 	//改进
    8. 	LTInsrt(phead, x);
    9. }

    🌕10.删除pos位置的结点

    10.1：步骤：

    ①：创建临时指针first保存pos前一个结点；

    ②：创建临时指针second保存pos后一个结点；

    ③：改变指针链接，删除pos结点:

    first->next = second; 

    second->prev = first;

    ④：释放pos结点。

    10.2：源代码
    1. //删除pos位置的结点
    2. void LTErase(ListNode* pos)
    3. {
    4. 	assert(pos);
    5. 	//临时指针
    6. 	ListNode* first = pos->prev;
    7. 	ListNode* second = pos->next;
    8. 	//删除
    9. 	first->next = second;
    10. 	second->prev = first;
    11. 	//释放pos
    12. 	free(pos);
    13. }
    10.3：有了这个算法，我们可以改进头删与尾删

    ①：当pos==phead->next时，即为头删算法：

    1. //头删
    2. void LTPopFront(ListNode* phead)
    3. {
    4. 	assert(phead);
    5.  
    6. 	//改进
    7. 	LTErase(phead->next);
    8. }

    ②：当pos==phead->prev时，即为尾删算法：

    1. //尾删
    2. void LTPopBack(ListNode* phead)
    3. {
    4. 	assert(phead);
    5.  
    6. 	//改进
    7. 	LTErase(phead->prev);
    8. }

    🍁五、测试源代码

    main.c

    1. #include"List.h"
    2.  
    3. void STTest1()
    4. {
    5. 	ListNode* plist = NULL;
    6. 	plist = Init();//初始化
    7. 	//尾插
    8. 	LTPushBack(plist, 1);
    9. 	LTPushBack(plist, 2);
    10. 	LTPushBack(plist, 3);
    11. 	LTPushBack(plist, 4);
    12. 	LTPushBack(plist, 5);
    13. 	//打印
    14. 	LTprint(plist);
    15. }
    16.  
    17. void STTest2()
    18. {
    19.  
    20. 	ListNode* plist = NULL;
    21. 	plist = Init();//初始化
    22. 	//尾插
    23. 	LTPushBack(plist, 1);
    24. 	//打印
    25. 	LTprint(plist);
    26. 	//尾删
    27. 	LTPopBack(plist);
    28. 	//打印
    29. 	LTprint(plist);
    30. }
    31.  
    32. void STTest3()
    33. {
    34. 	ListNode* plist = NULL;
    35. 	plist = Init();//初始化
    36. 	//头插
    37. 	LTPushFront(plist, 1);
    38. 	LTPushFront(plist, 2);
    39. 	//打印
    40. 	LTprint(plist);
    41. 	//头删
    42. 	LTPopFront(plist);
    43. 	//打印
    44. 	LTprint(plist);
    45. 	//头删
    46. 	LTPopFront(plist);
    47. 	//打印
    48. 	LTprint(plist);
    49. }
    50.  
    51. int main()
    52. {
    53. 	//STTest1();
    54. 	//STTest2();
    55. 	STTest3();
    56. 	return 0;
    57. }

    List.c

    1. #include"List.h"
    2.  
    3. //获得新结点
    4. ListNode* BuyLTNode(SLDataType x)
    5. {
    6. 	//用malloc函数动态生成即可
    7. 	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
    8. 	if (node == NULL)
    9. 	{
    10. 		//检查malloc错误原因
    11. 		perror("malloc");
    12. 		exit(-1);
    13. 	}
    14. 	//处理新结点的成员
    15. 	node->data = x;
    16. 	node->next = NULL;
    17. 	node->prev = NULL;
    18. 	return node;
    19. }
    20.  
    21. //初始化
    22. ListNode* Init()
    23. {
    24. 	//获得头结点，头结点数据域可以存点有意义的数据，也可以随便存，因为用不着
    25. 	ListNode* phead = BuyLTNode(0);
    26. 	//初始化头结点的两个指针域指向头结点本身表示为空表
    27. 	phead->next = phead;
    28. 	phead->prev = phead;
    29. 	return phead;
    30. }
    31.  
    32. //打印
    33. void LTprint(ListNode* phead)
    34. {
    35. 	assert(phead);
    36. 	//创建一个临时指针便于遍历操作
    37. 	ListNode* node = phead->next;
    38. 	//为了体现此链表结构而打印
    39. 	printf("phead<->");
    40. 	//打印数据,当临时指针node等于头结点时结束
    41. 	while (node != phead)
    42. 	{
    43. 		printf("%d<->", node->data);
    44. 		node = node->next;
    45. 	}
    46. 	//为了体现此链表结构而打印
    47. 	printf("phead\n");
    48. }
    49.  
    50. //尾插
    51. //因为带有头，所以操作只需要改变结构体，所以只需要结构体指针
    52. //具体操作看注释
    53. void LTPushBack(ListNode* phead, SLDataType x)
    54. {
    55. 	//因为是带头的，所以phead至少是个头指针，所以phead不可能为空，所以需要用assert检查一下
    56. 	assert(phead);
    57. 	找到尾结点tail
    58. 	//ListNode* tail = phead->prev;
    59. 	获取新结点newnode
    60. 	//ListNode* newnode = BuyLTNode(x);
    61. 	四步骤
    62. 	//tail->next = newnode;
    63. 	//newnode->prev = tail;
    64. 	//phead->prev = newnode;
    65. 	//newnode->next = phead;
    66.  
    67.  
    68. 	//改进
    69. 	LTInsrt(phead, x);
    70. }
    71.  
    72. //尾删
    73. void LTPopBack(ListNode* phead)
    74. {
    75. 	assert(phead);
    76. 	检查是否为空
    77. 	//if (phead->next == phead)
    78. 	//{
    79. 	//	printf("此链表为空，尾删失败！\n");
    80. 	//	return;
    81. 	//}
    82. 	临时指针保存结点
    83. 	//ListNode* tail1 = phead->prev;
    84. 	//ListNode* tail2 = phead->prev->prev;
    85. 	断开与尾结点的链接
    86. 	//tail2->next = phead;
    87. 	//phead->prev = tail2;
    88. 	释放尾结点
    89. 	//free(tail1);
    90.  
    91. 	//改进
    92. 	LTErase(phead->prev);
    93. }
    94.  
    95. //头插
    96. void LTPushFront(ListNode* phead, SLDataType x)
    97. {
    98. 	assert(phead);
    99. 	//新结点
    100. 	//ListNode* newnode = BuyLTNode(x);
    101. 	四步骤
    102. 	//newnode->next = phead->next;
    103. 	//phead->next->prev = newnode;
    104. 	//newnode->prev = phead;
    105. 	//phead->next = newnode;
    106.  
    107. 	//改进
    108. 	LTInsrt(phead->next, x);
    109. }
    110.  
    111. //头删
    112. void LTPopFront(ListNode* phead)
    113. {
    114. 	assert(phead);
    115. 	/*if (phead->next == phead)
    116. 	{
    117. 		printf("链表为空，头删失败！\n");
    118. 		return;
    119. 	}*/
    120. 	临时指针first指向首结点，便于后续释放首结点
    121. 	临时指针second指向第二个结点，便于进行删除操作
    122. 	//ListNode* first = phead->next;
    123. 	//ListNode* second = first->next;
    124. 	删除
    125. 	//second->prev = phead;
    126. 	//phead->next = second;
    127. 	释放首结点
    128. 	//free(first);
    129.  
    130. 	//改进
    131. 	LTErase(phead->next);
    132. }
    133.  
    134. //在pos位置之前插入结点
    135. void LTInsrt(ListNode* pos, SLDataType x)
    136. {
    137. 	assert(pos);
    138. 	//新结点
    139. 	ListNode* newnode = BuyLTNode(x);
    140. 	//插入
    141. 	pos->prev->next = newnode;
    142. 	newnode->prev = pos->prev;
    143. 	newnode->next = pos;
    144. 	pos->prev = newnode;
    145. }
    146.  
    147. //删除pos位置的结点
    148. void LTErase(ListNode* pos)
    149. {
    150. 	assert(pos);
    151. 	//临时指针
    152. 	ListNode* first = pos->prev;
    153. 	ListNode* second = pos->next;
    154. 	//删除
    155. 	first->next = second;
    156. 	second->prev = first;
    157. 	//释放pos
    158. 	free(pos);
    159. }

    List.h

    1. #pragma once
    2. #define _CRT_SECURE_NO_WARNINGS 1
    3. #include
    4. #include
    5. #include
    6.  
    7. typedef int SLDataType;
    8.  
    9. typedef struct ListNode
    10. {
    11. 	struct ListNode* prev;//指向前驱
    12. 	struct ListNode* next;//指向后继
    13. 	SLDataType data;//数据域
    14. }ListNode;
    15.  
    16. //获得一个新结点
    17. ListNode* BuyLTNode(SLDataType x);
    18.  
    19. //初始化
    20. ListNode* Init();
    21.  
    22. //打印
    23. void LTprint(ListNode* phead);
    24.  
    25. //尾插
    26. void LTPushBack(ListNode* phead,SLDataType x);
    27.  
    28. //尾删
    29. void LTPopBack(ListNode* phead);
    30.  
    31. //头插
    32. void LTPushFront(ListNode* phead, SLDataType x);
    33.  
    34. //头删
    35. void LTPopFront(ListNode* phead);
    36.  
    37. //在pos位置之前插入结点
    38. void LTInsrt(ListNode* pos, SLDataType x);
    39.  
    40. //删除pos位置的结点
    41. void LTErase(ListNode* pos);
    42.

    本次知识到此结束，希望对你有所帮助！

  • 相关阅读:
    详解【计算机类&面试真题】军队文职考试——第3期 | 何为网络延时？点对点P2P和端对端E2E的工作机制；管态和目态与进程状态的关系；为何要引入多道程序技术？计算机网络和分布式计算机系统的区别？...
    远程IO模块物联网应用提高工业自动化生产效率
    CentOS7.6（Linux）环境下有网和无网安装Docker
    上传大文件至 Git 仓库并使用 Git LFS 管理
    linux下grep命令使用总结
    DDD领域驱动设计-何时要用DDD
    Pinia基础知识
    如何用DOCKER容器安装开源Tryton ERP环境
    OPENFLOW协议协议分析实践
    响应式基础
  • 原文地址：https://blog.csdn.net/hffh123/article/details/133717402