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

【数据结构初阶】链表（下）——带头双向循环链表的实现_带头双向循环链表的基本实现

作者：从前慢现在也慢 | 2024-05-19 16:49:47

赞

踩

带头双向循环链表的基本实现

目录

带头双向循环链表的实现

        1.带头双向循环链表的节点类型

        2.创建带头双向循环链表的节点

        3.向带头双向循环链表中插入数据

                <3.1>从链表尾部插入数据

                <3.2>从链表头部插入数据

                <3.3>从链表某个节点前插入数据

        4.从带头双向循环链表中删除数据

                <4.1>从链表的尾部删除数据

                <4.2>从链表的头部删除数据

                <4.3>删除链表某个节点

        5.在带头双向循环链表中查找数据

        6.遍历带头双向循环链表

        7.销毁带头双向循环链表

带头双向循环链表实现总代码

测试

        1.测试代码

        2.测试效果

 链表总结

        无头单向非循环链表和带头双向循环链表的对比

        链表和顺序表的对比

本期博客我们来对最复杂的带头双向循环链表结构进行实现：

我们可以看到该种链表比单链表多了一个头节点（head（该节点一般不存放数据））和一个指向前一个节点的指针，该种类型的链表有着比单链表更多的优势，更适合来存储数据。

带头双向循环链表的实现

        1.带头双向循环链表的节点类型

在实现该链表之前我们先要确定节点类型：

  1. typedef int LTDataType;//数据类型
  2. typedef struct ListNode//节点类型
  3. {
  4. 	LTDataType _data;
  5. 	struct ListNode* _next;//指向后一个节点的指针
  6. 	struct ListNode* _prev;//指向前一个节点的指针
  7. }ListNode;

注：这里的对int类型进行重定义是为了我们更好的看懂Data只是一种数据而不仅仅是int类型。所以我们在使用链表时存储的数据并不限制于int类型，这里仅仅是举例。

        2.创建带头双向循环链表的节点

  1. ListNode* ListCreate()
  2. {
  3. 	ListNode* NewNode = (ListNode*)malloc(sizeof(ListNode));//向堆区申请一个节点大小的空间
  4. 	if (NewNode == NULL)//判断申请是否成功
  5. 	{
  6. 		perror("malloc");
  7. 		exit(-1);
  8. 	}
  9. 	NewNode->_next = NewNode;
  10. 	NewNode->_prev = NewNode;//将_next和_prev指针设为NewNode可以方便直接创建一个头节点
  11. 	return NewNode;//返回的指针的_next和_prev可以后期根据需要修改
  12. }

        3.向带头双向循环链表中插入数据

                <3.1>从链表尾部插入数据

  1. void ListPushBack(ListNode* pHead, LTDataType x)
  2. {
  3. 	assert(pHead);//传入的头节点不能为空
  4. 	ListNode* temp = pHead;
  5. 	ListNode* newnode = ListCreate();//申请一个新节点
  6. 	newnode->_data = x;//存入数据
  7. 	//下面是将新节点插入到链表的末尾的过程：
  8. 	newnode->_prev = temp->_prev;//将新节点_prev指针指向链表中最后一个节点
  9. 	newnode->_next = pHead;//将新节点_next指针指向链表中的头节点
  10. 	temp->_prev->_next = newnode;//将链表中最后一个节点的_next指向新节点
  11. 	temp->_prev = newnode;//将头节点的_prev指针指向新节点
  12. }

                <3.2>从链表头部插入数据

  1. void ListPushFront(ListNode* pHead, LTDataType x)
  2. {
  3. 	assert(pHead);//传入的头节点不能为空
  4. 	ListNode* temp = pHead;
  5. 	ListNode* newnode = ListCreate();//申请一个新节点
  6. 	newnode->_data = x;//存入数据
  7. 	//下面是将新节点插入到链表的头部的过程：
  8. 	newnode->_prev = temp;//将新节点_prev指针指向链表中头节点
  9. 	newnode->_next = temp->_next;//将新节点_next指针指向链表中的第一个数据节点
  10. 	temp->_next->_prev = newnode;//将链表中第一个数据节点的_perv指向新节点
  11. 	temp->_next = newnode;//将头节点的_next指针指向新节点
  12. }

                <3.3>从链表某个节点前插入数据

  1. void ListInsert(ListNode* pos, LTDataType x)//pos传入将要插入其前的节点
  2. {
  3. 	assert(pos);//传入的节点不能为空
  4. 	ListNode* temp = pos;
  5. 	ListNode* newnode = ListCreate();//申请一个新节点
  6. 	newnode->_data = x;//存入数据
  7. 	//下面是将新节点插入到链表pos节点前的过程：
  8. 	newnode->_prev = temp->_prev;//将新节点_prev指针指向pos节点的前一个节点
  9. 	newnode->_next = temp;//将新节点_next指针指向pos节点
  10. 	temp->_prev->_next = newnode;//将pos前一个节点的_next指针指向新节点
  11. 	temp->_prev = newnode;//将pos节点的_prev指针指向新节点
  12. }

        4.从带头双向循环链表中删除数据

                <4.1>从链表的尾部删除数据

  1. void ListPopBack(ListNode* pHead)
  2. {
  3. 	assert(pHead);//传入的头节点不能为空
  4. 	assert(pHead->_prev);//链表不能为空
  5. 	ListNode* Del = pHead->_prev;
  6. 	//下面是将最后一个数据节点删除过程：
  7. 	Del->_prev->_next = Del->_next;//将最后一个数据节点的上一个节点的_next指针指向头节点
  8. 	Del->_next->_prev = Del->_prev;//将头节点的_next指针指向最后一个数据节点的上一个节点
  9. 	free(Del);//释放最后一个数据节点的空间
  10. 	Del = NULL;//防止野指针的产生
  11. }

                <4.2>从链表的头部删除数据

  1. void ListPopFront(ListNode* pHead)
  2. {
  3. 	assert(pHead);//传入的头节点不能为空
  4. 	assert(pHead->_next);//链表不能为空
  5. 	ListNode* Del = pHead->_next;
  6. 	//下面是将第一个数据节点删除过程：
  7. 	Del->_next->_prev = Del->_prev;//将第一个数据节点的下一个节点的_prev指针指向头节点
  8. 	Del->_prev->_next = Del->_next;//将头节点的_next指针指向第一个数据节点的下一个节点
  9. 	free(Del);//释放第一个数据节点的空间
  10. 	Del = NULL;//防止野指针的产生
  11. }

                <4.3>删除链表某个节点

  1. void ListErase(ListNode* pos)//pos传入要删除的节点
  2. {
  3. 	assert(pos);//传入的节点不能为空
  4. 	ListNode* Del = pos;
  5. 	//下面是将pos数据节点删除过程：
  6. 	Del->_prev->_next = Del->_next;//将pos数据节点的前一个节点的_next指针指向pos数据节点的下一个节点
  7. 	Del->_next->_prev = Del->_prev;//将pos数据节点的下一个节点的_prev指针指向pos数据节点的上一个节点
  8. 	free(Del);//释放pos数据节点的空间
  9. 	Del = NULL;//防止野指针的产生
  10. }

        5.在带头双向循环链表中查找数据

  1. ListNode* ListFind(ListNode* pHead, LTDataType x)
  2. {
  3. 	assert(pHead);//传入的头节点不能为空
  4. 	ListNode* find = pHead->_next;//跳过头节点开始查找
  5. 	while (find != pHead)
  6. 	{
  7. 		if (find->_data == x)
  8. 			return find;//找到返回该节点
  9. 		find = find->_next;
  10. 	}
  11. 	return NULL;//没找到返回空指针
  12. }

        6.遍历带头双向循环链表

  1. void ListPrint(ListNode* pHead)
  2. {
  3. 	assert(pHead);
  4. 	printf("Head->");
  5. 	ListNode* print = pHead->_next;//跳过头节点开始打印
  6. 	while (print != pHead)
  7. 	{
  8. 		printf("%d->", print->_data);
  9. 		print = print->_next;
  10. 	}
  11. 	printf("Head\n");
  12. }

        7.销毁带头双向循环链表

  1. void ListDestory(ListNode* pHead)
  2. {
  3. 	assert(pHead);
  4. 	ListNode* Del = pHead->_next;//跳过头节点开始删除节点
  5. 	ListNode* temp = Del;
  6. 	while (Del != pHead)
  7. 	{
  8. 		temp = temp->_next;
  9. 		free(Del);
  10. 		Del = temp;
  11. 	}
  12. 	pHead->_next = pHead;
  13. 	pHead->_prev = pHead;//将链表置空
  14. }

带头双向循环链表实现总代码

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<assert.h>
  4. // 带头+双向+循环链表增删查改实现
  5. typedef int LTDataType;
  6. typedef struct ListNode
  7. {
  8. 	LTDataType _data;
  9. 	struct ListNode* _next;
  10. 	struct ListNode* _prev;
  11. }ListNode;
  12.  
  13. ListNode* ListCreate()
  14. {
  15. 	ListNode* NewNode = (ListNode*)malloc(sizeof(ListNode));//向堆区申请一个节点大小的空间
  16. 	if (NewNode == NULL)//判断申请是否成功
  17. 	{
  18. 		perror("malloc");
  19. 		exit(-1);
  20. 	}
  21. 	NewNode->_next = NewNode;//防止野指针的产生
  22. 	NewNode->_prev = NewNode;//防止野指针的产生
  23. 	return NewNode;
  24. }
  25. // 双向链表尾插
  26. void ListPushBack(ListNode* pHead, LTDataType x)
  27. {
  28. 	assert(pHead);//传入的头节点不能为空
  29. 	ListNode* temp = pHead;
  30. 	ListNode* newnode = ListCreate();//申请一个新节点
  31. 	newnode->_data = x;//存入数据
  32. 	//下面是将新节点插入到链表的末尾的过程：
  33. 	newnode->_prev = temp->_prev;//将新节点_prev指针指向链表中最后一个节点
  34. 	newnode->_next = temp;//将新节点_next指针指向链表中的头节点
  35. 	temp->_prev->_next = newnode;//将链表中最后一个节点的_next指向新节点
  36. 	temp->_prev = newnode;//将头节点的_prev指针指向新节点
  37. }
  38. // 双向链表头插
  39. void ListPushFront(ListNode* pHead, LTDataType x)
  40. {
  41. 	assert(pHead);//传入的头节点不能为空
  42. 	ListNode* temp = pHead;
  43. 	ListNode* newnode = ListCreate();//申请一个新节点
  44. 	newnode->_data = x;//存入数据
  45. 	//下面是将新节点插入到链表的头部的过程：
  46. 	newnode->_prev = temp;//将新节点_prev指针指向链表中头节点
  47. 	newnode->_next = temp->_next;//将新节点_next指针指向链表中的第一个数据节点
  48. 	temp->_next->_prev = newnode;//将链表中第一个数据节点的_perv指向新节点
  49. 	temp->_next = newnode;//将头节点的_next指针指向新节点
  50. }
  51. // 双向链表在pos的前面进行插入
  52. void ListInsert(ListNode* pos, LTDataType x)
  53. {
  54. 	assert(pos);//传入的节点不能为空
  55. 	ListNode* temp = pos;
  56. 	ListNode* newnode = ListCreate();//申请一个新节点
  57. 	newnode->_data = x;//存入数据
  58. 	//下面是将新节点插入到链表pos节点前的过程：
  59. 	newnode->_prev = temp->_prev;//将新节点_prev指针指向pos节点的前一个节点
  60. 	newnode->_next = temp;//将新节点_next指针指向pos节点
  61. 	temp->_prev->_next = newnode;//将pos前一个节点的_next指针指向新节点
  62. 	temp->_prev = newnode;//将pos节点的_prev指针指向新节点
  63. }
  64. // 双向链表尾删
  65. void ListPopBack(ListNode* pHead)
  66. {
  67. 	assert(pHead);//传入的头节点不能为空
  68. 	assert(pHead->_prev);//链表不能为空
  69. 	ListNode* Del = pHead->_prev;
  70. 	//下面是将最后一个数据节点删除过程：
  71. 	Del->_prev->_next = Del->_next;//将最后一个数据节点的上一个节点的_next指针指向头节点
  72. 	Del->_next->_prev = Del->_prev;//将头节点的_next指针指向最后一个数据节点的上一个节点
  73. 	free(Del);//释放最后一个数据节点的空间
  74. 	Del = NULL;//防止野指针的产生
  75. }
  76. // 双向链表头删
  77. void ListPopFront(ListNode* pHead)
  78. {
  79. 	assert(pHead);//传入的头节点不能为空
  80. 	assert(pHead->_next);//链表不能为空
  81. 	ListNode* Del = pHead->_next;
  82. 	//下面是将第一个数据节点删除过程：
  83. 	Del->_next->_prev = Del->_prev;//将第一个数据节点的下一个节点的_prev指针指向头节点
  84. 	Del->_prev->_next = Del->_next;//将头节点的_next指针指向第一个数据节点的下一个节点
  85. 	free(Del);//释放第一个数据节点的空间
  86. 	Del = NULL;//防止野指针的产生
  87. }
  88. // 双向链表删除pos位置的节点
  89. void ListErase(ListNode* pos)
  90. {
  91. 	assert(pos);//传入的节点不能为空
  92. 	ListNode* Del = pos;
  93. 	//下面是将pos数据节点删除过程：
  94. 	Del->_prev->_next = Del->_next;//将pos数据节点的前一个节点的_next指针指向pos数据节点的下一个节点
  95. 	Del->_next->_prev = Del->_prev;//将pos数据节点的下一个节点的_prev指针指向pos数据节点的上一个节点
  96. 	free(Del);//释放pos数据节点的空间
  97. 	Del = NULL;//防止野指针的产生
  98. }
  99. // 双向链表查找
  100. ListNode* ListFind(ListNode* pHead, LTDataType x)
  101. {
  102. 	assert(pHead);//传入的头节点不能为空
  103. 	ListNode* find = pHead->_next;//跳过头节点开始查找
  104. 	while (find != pHead)
  105. 	{
  106. 		if (find->_data == x)
  107. 			return find;//找到返回该节点
  108. 		find = find->_next;
  109. 	}
  110. 	return NULL;//没找到返回空指针
  111. }
  112. // 双向链表打印
  113. void ListPrint(ListNode* pHead)
  114. {
  115. 	assert(pHead);
  116. 	printf("Head->");
  117. 	ListNode* print = pHead->_next;//跳过头节点开始打印
  118. 	while (print != pHead)
  119. 	{
  120. 		printf("%d->", print->_data);
  121. 		print = print->_next;
  122. 	}
  123. 	printf("Head\n");
  124. }
  125. // 双向链表销毁
  126. void ListDestory(ListNode* pHead)
  127. {
  128. 	assert(pHead);
  129. 	ListNode* Del = pHead->_next;//跳过头节点开始删除节点
  130. 	ListNode* temp = Del;
  131. 	while (Del != pHead)
  132. 	{
  133. 		temp = temp->_next;
  134. 		free(Del);
  135. 		Del = temp;
  136. 	}
  137. 	pHead->_next = pHead;
  138. 	pHead->_prev = pHead;
  139. }

测试

        1.测试代码

  1. int main()
  2. {
  3. 	ListNode* Head= ListCreate();
  4. 	ListPrint(Head);
  5. 	ListPushBack(Head, 1);
  6. 	ListPrint(Head);
  7. 	ListPushBack(Head, 2);
  8. 	ListPrint(Head);
  9. 	ListPushBack(Head, 3);
  10. 	ListPrint(Head);
  11. 	ListPushBack(Head, 4);
  12. 	ListPrint(Head);
  13. 	ListPushFront(Head, 5);
  14. 	ListPrint(Head);
  15. 	ListInsert(ListFind(Head, 5), 6);
  16. 	ListPrint(Head);
  17. 	ListPopFront(Head);
  18. 	ListPrint(Head);
  19. 	ListPopFront(Head);
  20. 	ListPrint(Head);
  21. 	ListPopBack(Head);
  22. 	ListPrint(Head);
  23. 	ListErase(ListFind(Head, 2));
  24. 	ListPrint(Head);
  25. 	ListDestory(Head);
  26. 	ListPrint(Head);
  27. 	return 0;
  28. }

        2.测试效果


 
链表总结

        无头单向非循环链表和带头双向循环链表的对比

        在我们实现完无头单向非循环链表和带头双向循环链表之后发现带头双向循环链表虽然结构复杂但是在尾插尾删时不用遍历整个链表，并且在实际使用时也比单链表更方便操作，具有绝对的优势，所以在存储数据时尝尝使用的是带头双向循环链表。

        链表和顺序表的对比

存储空间上：              顺序表物理空间上一定连续。

                                    链表在逻辑上连续，但在物理空间上不一定连续（具体要看malloc函数的分配了）。

在访问数据时：           顺序表可以随机访问，时间复杂度为O(1)。

                                    链表不可以随机访问，时间复杂度为O(N)。

在插入(删除)数据时： 顺序表可能需要移动元素，效率低，时间复杂度为O(N)。

                                    链表只需要改变指针指向，效率高，时间复杂度为O(N)。

添加数据时：              动态顺序表可能需要扩容。

                                   链表添加一个数据开辟一块空间没有扩容概念。

应用场景：                 顺序表一般运用在元素高效存储和频繁访问的场景。

                                   链表一般运用在任意位置插入和删除频繁的场景。

缓存利用率：             顺序表开辟的空间全部都用来存储数据，利用率高。

                                   链表开辟的一部分空间用来存储指针，利用率低。

数据结构的初阶链表到这里就结束了，代码量较多难免会有不足之处，还请各位大佬在评论区赐教！

各位看客咱们下一期见~

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

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

  

闽ICP备14008679号