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

【数据结构】带头节点双向循环链表_带头结点的双向循环链表l长度为

作者：繁依Fanyi0 | 2024-06-11 00:25:36

赞

踩

带头结点的双向循环链表l长度为

目录

顺序表和链表的区别

带头双向循环链表分析

带头双向循环链表结构：

 创建一个节点

哨兵位头节点

打印链表中的值

在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<stdio.h>
  3. #include<assert.h>
  4. #include<stdlib.h>
  5. #include<stdbool.h>
  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. }

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

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

  

闽ICP备14008679号