• 【数据结构】带头节点双向循环链表

    目录

    顺序表和链表的区别

    带头双向循环链表分析

    带头双向循环链表结构：

     创建一个节点

    哨兵位头节点

    打印链表中的值

    在pos前插入

    删除pos位置的节点

    尾插

    尾删

    头插：

    头删

    链表元素查找

    总代码

     List.h文件

    List.c文件

    test.c文件

    顺序表和链表的区别

     

            顺序表：

    优点：尾插尾删效率高，下标的随机访问快。

    缺点：空间不够需要扩容（扩容空间大）；头部或中间插入删除效率低，需要挪动数据。

            链表：

    优点：需要扩容，按需申请释放大小快节点内存；任意位置插入效率高——O(1).

    缺点：不支持下标随机访问。

    链表类型有8种：

     

     虽然有这么多的链表结构，但是实际中最常用的还是如下图两种结构：

    1、无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多的是作为其他数据结构的子结构，如哈希表、图的邻接表等。这两种结构在笔试面试种出现很多。

    2、带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然复杂，但是使用代码实现后以后会发现结构带来了很多优势，实现反而简单了。

    带头双向循环链表分析

    带头双向循环链表结构：

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

     

     创建一个节点

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

    哨兵位头节点

    1. LTNode* LTInit()                     //头节点（哨兵位）
    2. {
    3. 	LTNode* phead = BuyListNode(-1);
    4. 	phead->next = phead;
    5. 	phead->prev= phead;
    6. 	return phead;
    7. }

    打印链表中的值

    1. void LTPrint(LTNode*phead)
    2. {
    3. 	assert(phead);
    4. 	LTNode* cur = phead->next;
    5. 	while (cur != phead)
    6. 	{
    7. 		printf("%d ", cur->data);
    8. 		cur = cur->next;
    9. 	}
    10. 	printf("\n");
    11. }

    这里需要注意一下打印结束的标志，单链表的打印结束标志位最后一个节点为空，即while（cur）；而带头双向循环链表的打印结束标志是最后一个节点指向哨兵位节点，即while(cur！= phead)。

    在pos前插入

    在pos位置之前插入值时，注意先将pos的前一个节点的地址记下来，再插入值：

     

    1. void LTInsert(LTNode* pos, LTDataType x)
    2. {
    3. 	assert(pos);
    4. 	LTNode* prev = pos->prev;
    5. 	LTNode* newnode = BuyListNode(x);
    6.  
    7. 	prev->next = newnode;
    8. 	newnode->prev = prev;
    9. 	newnode->next = pos;
    10. 	pos->prev = newnode;
    11. }

    删除pos位置的节点

     删除pos位置的节点之前可以将pos的前一个节点和pos后一个节点的地址记下来：

     

     

    1. //删除pos位置
    2. void LTErase(LTNode* pos)
    3. {
    4. 	assert(pos);
    5. 	LTNode* prev = pos->prev;
    6. 	LTNode* next = pos->next;
    7.  
    8. 	prev->next = next;
    9. 	next->prev = prev;
    10. 	free(pos);
    11. }

    尾插

    相当于在phead前面插入一个值，而哨兵位节点的地址没有改变。在带哨兵位双向循环链表中，哨兵位的前一个节点指向的地址（phead->prev）相当于最后一个，因为此链表中第一个节点的地址是phead->next:

    1. void LTPushBack(LTNode*phead,LTDataType x)
    2. {
    3. 	assert(phead);
    4. 	/*LTNode* newnode = BuyListNode(x);
    5. 	LTNode* tail = phead->prev;
    7. 	tail->next = newnode;
    8. 	newnode->prev = tail;
    10. 	newnode->next = phead;
    11. 	phead->prev = newnode;*/
    12. 	LTInsert(phead, x);//相当于在phead之前插入一个节点，此时的哨兵节点的位置仍然指向phead,phead->pre为尾节点（双链表）
    13.  
    14. }

    尾删

    相当于将哨兵位前一个节点（phead->prev）给free掉：

    1. void LTPopBack(LTNode* phead)
    2. {
    3. 	assert(phead);
    4. 	assert(phead->next != NULL);  // 哨兵位的下一位不为空
    5. /*
    6. LTNode* tail = phead->prev;
    7. 	LTNode* tailprev = tail->prev;
    9. 	phead->prev = tailprev;
    10. 	tailprev->next = phead;
    11. 	free(tail);
    13. */
    14. 	LTErase(phead->prev);
    15. }

    头插：

    相当于在哨兵位后一个节点之前插入：

     

    1. void LTPushFront(LTNode* phead, LTDataType x)
    2. {
    3. 	assert(phead);
    4. /*
    5. LTNode* newnode = BuyListNode(x);
    6. 	LTNode*first = phead->next;           //first记住phead->next的地址；
    8. 	newnode->next = first;
    9. 	newnode->prev = phead;
    10. 	first->prev = newnode;
    12. 	phead->next = newnode;
    13. */
    14. 	LTInsert(phead->next, x);
    15. }

    头删

    删除哨兵位(phead)的后一个节点(phead->next):

     

    1. void LTPopFront(LTNode* phead)
    2. {
    3. 	assert(phead);
    4. 	assert(phead->next != NULL);//哨兵位的下一位即第一个节点不为空
    5. /*
    6. 	LTNode* first = phead->next;//first记住头节点地址
    7. 	LTNode* second = first->next;
    9. 	phead->next = second;
    10. 	second->prev = phead;
    11. 	free(first);
    13. */
    14. 	LTErase(phead->next);
    15. }

    注释掉的代码也是可以运行的，相当于LTErase(phead->next) 

    链表元素查找

    如果一直查找，直到找到哨兵位节点还没找到，则返回NULL;

    1. LTNode* LTFind(LTNode* phead, LTDataType x)
    2. {
    3. 	assert(phead);
    4. 	LTNode* cur = phead->next;
    5. 	while (cur != phead)
    6. 	{
    7. 		if (cur->data == x)
    8. 		{
    9. 			return cur;
    10. 		}
    11. 		cur = cur->next;
    12. 	}
    13. 	return NULL;
    14. }

    总代码

     List.h文件

    在此声明函数和定义链表的结构体

    1. #pragma once
    2. #include
    3. #include
    4. #include
    5. #include
    6.  
    7. typedef int LTDataType;
    8. typedef struct ListNode
    9. {
    10. 	struct ListNode* next;           //后一个节点地址
    11. 	struct ListNode* prev;          //前一个节点地址
    12. 	LTDataType data;
    13. }LTNode;
    14.  
    15. LTNode* BuyListNode(LTDataType x);//新建一个节点
    16. LTNode* LTInit();
    17.  
    18. void LTPrint(LTNode* phead);                 //打印
    19. void LTPushBack(LTNode* phead, LTDataType x);//尾插
    20. void LTPopBack(LTNode* phead);               //尾删
    21.  
    22. void LTPushFront(LTNode* phead, LTDataType x);//头插
    23. void LTPopFront(LTNode* phead);
    24.  
    25. LTNode* LTFind(LTNode* phead, LTDataType x);//查找双链表的元素
    26.  
    27. //pos插入x
    28. void LTInsert(LTNode* pos, LTDataType x);
    29. //pos删除
    30. void LTErase(LTNode* pos);
    31.  
    32. bool LTEmpty(LTNode* phead);
    33. size_t LTSize(LTNode* phead);    //双链表长度
    34. void LTDestroy(LTNode* phead);

    List.c文件

    在此定义函数

    1. #define  _CRT_SECURE_NO_WARNINGS
    2. #include"List.h"
    3.  
    4. LTNode *BuyListNode(LTDataType x)
    5. {
    6. 	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
    7. 	if (newnode == NULL)
    8. 	{
    9. 		perror("malloc fail");
    10. 		exit(-1);
    11. 	}
    12. 	newnode->prev = NULL;
    13. 	newnode->next = NULL;
    14. 	newnode->data = x;
    15. 	return newnode;
    16. }
    17.  
    18. LTNode* LTInit()                     //头节点（哨兵位）
    19. {
    20. 	LTNode* phead = BuyListNode(-1);
    21. 	phead->next = phead;
    22. 	phead->prev= phead;
    23. 	return phead;
    24. }
    25.  
    26. void LTPrint(LTNode*phead)
    27. {
    28. 	assert(phead);
    29. 	LTNode* cur = phead->next;
    30. 	while (cur != phead)
    31. 	{
    32. 		printf("%d ", cur->data);
    33. 		cur = cur->next;
    34. 	}
    35. 	printf("\n");
    36. }
    37.  
    38. void LTPushBack(LTNode*phead,LTDataType x)
    39. {
    40. 	assert(phead);
    41. 	/*LTNode* newnode = BuyListNode(x);
    42. 	LTNode* tail = phead->prev;
    44. 	tail->next = newnode;
    45. 	newnode->prev = tail;
    47. 	newnode->next = phead;
    48. 	phead->prev = newnode;*/
    49. 	LTInsert(phead, x);//相当于在phead之前插入一个节点，此时的哨兵节点的位置仍然指向phead,phead->pre为尾节点（双链表）
    50.  
    51. }
    52.  
    53. void LTPopBack(LTNode* phead)
    54. {
    55. 	assert(phead);
    56. 	assert(phead->next != NULL);  // 哨兵位的下一位不为空
    57. /*
    58. LTNode* tail = phead->prev;
    59. 	LTNode* tailprev = tail->prev;
    61. 	phead->prev = tailprev;
    62. 	tailprev->next = phead;
    63. 	free(tail);
    65. */
    66. 	LTErase(phead->prev);
    67. }
    68. 	
    69.  
    70. void LTPushFront(LTNode* phead, LTDataType x)
    71. {
    72. 	assert(phead);
    73. /*
    74. LTNode* newnode = BuyListNode(x);
    75. 	LTNode*first = phead->next;           //first记住phead->next的地址；
    77. 	newnode->next = first;
    78. 	newnode->prev = phead;
    79. 	first->prev = newnode;
    81. 	phead->next = newnode;
    82. */
    83. 	LTInsert(phead->next, x);
    84. }
    85.  
    86. void LTPopFront(LTNode* phead)
    87. {
    88. 	assert(phead);
    89. 	assert(phead->next != NULL);//哨兵位的下一位即第一个节点不为空
    90. /*
    91. 	LTNode* first = phead->next;//first记住头节点地址
    92. 	LTNode* second = first->next;
    94. 	phead->next = second;
    95. 	second->prev = phead;
    96. 	free(first);
    98. */
    99. 	LTErase(phead->next);
    100. }
    101. //在pos之前插入x
    102. void LTInsert(LTNode* pos, LTDataType x)
    103. {
    104. 	assert(pos);
    105. 	LTNode* prev = pos->prev;
    106. 	LTNode* newnode = BuyListNode(x);
    107.  
    108. 	prev->next = newnode;
    109. 	newnode->prev = prev;
    110. 	newnode->next = pos;
    111. 	pos->prev = newnode;
    112. }
    113. //删除pos位置
    114. void LTErase(LTNode* pos)
    115. {
    116. 	assert(pos);
    117. 	LTNode* prev = pos->prev;
    118. 	LTNode* next = pos->next;
    119.  
    120. 	prev->next = next;
    121. 	next->prev = prev;
    122. 	free(pos);
    123. }
    124.  
    125. bool LTEmpty(LTNode* phead)
    126. {
    127. 	assert(phead);
    128. 	/*
    129. 	if(phead->next==phead)
    130. 	{
    131. 		return true;
    132. 	}
    133. 	else
    134. 	{
    135. 		return false;
    136. 	}
    137. 	*/
    138. 	return phead->next == phead;
    139. }
    140.  
    141. size_t LTSize(LTNode* phead)
    142. {
    143. 	assert(phead);
    144.  
    145. 	size_t size = 0;
    146. 	LTNode* cur = phead->next;
    147. 	while (cur != phead)
    148. 	{
    149. 		++size;
    150. 		cur = cur->next;
    151. 	}
    152. 	return size;
    153. }
    154.  
    155. void LTDestroy(LTNode* phead)
    156. {
    157. 	assert(phead);
    158. 	LTNode* cur = phead->next;
    159. 	LTNode* next = NULL;
    160. 	while (cur != phead)
    161. 	{
    162. 		 next = cur->next;
    163. 		free(cur);
    164. 		cur = next;
    165. 	}
    166. 	free(phead);
    167. }
    168.  
    169. LTNode* LTFind(LTNode* phead, LTDataType x)
    170. {
    171. 	assert(phead);
    172. 	LTNode* cur = phead->next;
    173. 	while (cur != phead)
    174. 	{
    175. 		if (cur->data == x)
    176. 		{
    177. 			return cur;
    178. 		}
    179. 		cur = cur->next;
    180. 	}
    181. 	return NULL;
    182. }

    test.c文件

    在此测试和放主函数

    1. #define  _CRT_SECURE_NO_WARNINGS
    2. #include"List.h"
    3. void testLTNode1()
    4. {
    5. 	LTNode* phead = LTInit();
    6. 	LTPushBack(phead, 1);
    7. 	LTPushBack(phead, 2);
    8. 	LTPushBack(phead, 2);
    9. 	LTPushBack(phead, 3);
    10. 	LTPushBack(phead, 4);
    11. 	LTPrint(phead);
    12.  
    13. 	LTPopBack(phead);
    14. 	LTPopBack(phead);
    15. 	LTPopBack(phead);
    16. 	LTPrint(phead);
    17.  
    18. 	LTPushFront(phead, 1);
    19. 	LTPushFront(phead, 2);
    20. 	LTPushFront(phead, 3);
    21. 	LTPushFront(phead, 4);
    22. 	LTPrint(phead);
    23.  
    24. 	LTPopFront(phead);
    25. 	LTPopFront(phead);
    26. 	LTPrint(phead);
    27. }
    28.  
    29. void testLTNode2()
    30. {
    31. 	LTNode* phead = LTInit();
    32. 	LTPushFront(phead, 1);
    33. 	LTPushFront(phead, 2);
    34. 	LTPushFront(phead, 3);
    35. 	LTPushFront(phead, 4);
    36. 	LTPrint(phead);
    37. 	LTNode* pos = LTFind(phead, 3);
    38. 	if (pos)
    39. 	{
    40. 		pos->data *= 10;
    41. 	}
    42. 	LTPrint(phead);
    43.  
    44. 	pos = LTFind(phead, 30);
    45. 	LTErase(pos);
    46. 	LTPrint(phead);
    47.  
    48. 	pos = LTFind(phead, 4);
    49. 	LTInsert(pos, 3);
    50. 	LTPrint(phead);
    51.  
    52. 	pos = NULL;
    53. 	LTDestroy(phead);
    54. 	phead = NULL;
    55. }
    56.  
    57. int main()
    58. {
    59. 	//testLTNode1();
    60. 	testLTNode2();
    61. 	return 0;
    62. }

  • 相关阅读:
    通讯网关软件023——利用CommGate X2HTTP实现HTTP访问Modbus TCP
    上周热点回顾（10.10-10.16）
    js页面window.onload()=$(function(){}) 和$(docunment).ready(function(){})
    【2024秋招】2023-10-9 同花顺后端笔试题
    【数字图像处理】RGB 转灰度图
    【机器学习 吴恩达】 学习笔记一：引言、二：单变量线性回归、三：线性代数
    地址解析协议ARP
    淘宝商品详情API接口（H5端和APP端），淘宝详情页，商品属性接口,商品信息查询
    java基于springboot+vue的课程资源在线学习网站
    【c++每天一题】 字符串压缩
  • 原文地址：https://blog.csdn.net/weixin_53269843/article/details/127970125