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

数据结构（初阶）—— C语言实现双向带头循环链表_c实现双向循环链表

作者：AllinToyou | 2024-06-04 03:05:38

赞

踩

c实现双向循环链表

 

目录

一、链表种类的优劣

二、什么是双向循环链表 

三，双向循环链表各接口函数实现 

1.双链表的初始化

2.双链表的打印 

3.扩容函数 

4.双链表的尾插 

5.双链表的尾删

6.双链表的头插

7.双链表的头删 

8.双链表的查找

9. 双链表在pos位置之前插入结点

10.双链表删除pos位置的结点 

11.双链表的销毁 

四、源代码 

List.h

List.c

test.c

五、顺序表和双向链表的总结

1.顺序表的优点与缺点

2. 双向链表的优点与缺点

一、链表种类的优劣

链表可分为8种：

单向双向
单向带头循环双向带头循环
单向带头不循环双向带头不循环
单向不带头循环双向不带头循环
单向不带头不循环双向不带头不循环

在C语言实现链表那篇博客中https://blog.csdn.net/sjsjnsjnn/article/details/123920224?spm=1001.2014.3001.5501

主要实现的是单向不带头非循环的链表结构；

此结构：

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

二、什么是双向循环链表 

     双向循环链表和单链表都是由结点组成的，单链表包含一个数据域和一个指针域构成，而双向循环链表不同，它是由一个数据域和两个指针域组成，其中指针包含前驱指针（prev）和后继指针（next）；

三，双向循环链表各接口函数实现 

1.双链表的初始化

  1. //双向带头循环链表的初始化
  2. LTNode* ListInit()
  3. {
  4. 	LTNode* phead = (LTNode*)malloc(sizeof(LTNode));//创建头结点
  5. 	phead->next = phead;//后继指针指向头
  6. 	phead->prev = phead;//前驱指针指向头
  7. 	return phead;
  8. }

2.双链表的打印 

  1. //双向带头循环链表的打印
  2. void ListPrint(LTNode* phead)
  3. {
  4. 	assert(phead);
  5. 	LTNode* cur = phead->next;
  6. 	while (cur != phead)
  7. 	{
  8. 		printf("%d->", cur->Data);
  9. 		cur = cur->next;
  10. 	}
  11. 	printf("\n");
  12. }

3.扩容函数 

  1. //增容函数
  2. LTNode* BuyListNode(LTDataType x)
  3. {
  4. 	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
  5. 	if (newnode == NULL)
  6. 	{
  7. 		printf("malloc fail\n");
  8. 		exit(-1);
  9. 	}
  10. 	newnode->Data = x;
  11. 	newnode->next = NULL;
  12. 	newnode->prev = NULL;
  13. 	return newnode;
  14. }

4.双链表的尾插 

  1. //双向带头循环链表的尾插
  2. void ListPushBack(LTNode* phead, LTDataType x)
  3. {
  4. 	assert(phead);
  5. 	LTNode* tail = phead->prev;
  6. 	LTNode* newnode = BuyListNode(x);
  7. 	tail->next = newnode;
  8. 	newnode->prev = tail;
  9. 	newnode->next = phead;
  10. 	phead->prev = newnode;
  11. }

5.双链表的尾删

  1. //双向带头循环链表的尾删
  2. void ListPopBack(LTNode* phead)
  3. {
  4. 	assert(phead);
  5. 	assert(phead->next != phead);
  6. 	LTNode* tail = phead->prev;
  7. 	LTNode* tailprev = tail->prev;
  8. 	free(tail);
  9. 	tailprev->next = phead;
  10. 	phead->prev = tailprev;
  11. 	//ListErase(phead->prev);//尾删就相当于复用Erase这个函数
  12. }

 

6.双链表的头插

  1. //双向带头循环链表的头插
  2. void ListPushFront(LTNode* phead, LTDataType x)
  3. {
  4. 	assert(phead);
  5. 	LTNode* newnode = BuyListNode(x);
  6. 	LTNode* next = phead->next;//先找到头
  7. 	phead->next = newnode;
  8. 	newnode->prev = phead;
  9. 	newnode->next = next;
  10. 	next->prev = newnode;
  11. 	//ListInsert(phead->next, x);
  12. }

 

7.双链表的头删 

  1. //双向带头循环链表的头删
  2. void ListPopFront(LTNode* phead)
  3. {
  4. 	assert(phead);
  5. 	assert(phead->next != phead);//如果哨兵位的后继指针指向的是头，就不能去调用头删
  6. 	LTNode* next = phead->next;//先找到头结点
  7. 	LTNode* nextNext = next->next;//再找到头结点的下一个结点
  8. 	phead->next = next->next;
  9. 	nextNext->prev = phead;
  10. }

 

8.双链表的查找

  1. //双向带头循环链表的查找
  2. LTNode* ListFind(LTNode* phead, LTDataType x)
  3. {
  4. 	assert(phead);
  5. 	LTNode* cur = phead->next;//从头结点出发
  6. 	while (cur != phead)
  7. 	{
  8.         //找到返回对应的地址
  9. 		if (cur->Data == x)
  10. 		{
  11. 			return cur;
  12. 		}
  13.         //找不到继续向后找
  14. 		cur = cur->next;
  15. 	}
  16.     //彻底找不到
  17. 	return NULL;
  18. }

9. 双链表在pos位置之前插入结点

  1. //双向带头循环链表pos位置之前插入
  2. void ListInsert(LTNode* pos, LTDataType x)
  3. {
  4. 	assert(pos);
  5. 	LTNode* posPrev = pos->prev;//先找到pos的前一个结点的位置
  6. 	LTNode* newnode = BuyListNode(x);
  7. 	posPrev->next = newnode;
  8. 	newnode->prev = posPrev;
  9. 	newnode->next = pos;
  10. 	pos->prev = newnode;
  11. }

10.双链表删除pos位置的结点 

  1. //双向带头循环链表pos位置删除
  2. void ListErase(LTNode* pos)
  3. {
  4. 	assert(pos);
  5. 	LTNode* posPrev = pos->prev;//找到pos的前一个位置
  6. 	LTNode* posNext = pos->next;//和pos的后一个位置
  7.     //把前一个结点和后一个结点链接起来
  8. 	posPrev->next = posNext;
  9. 	posNext->prev = posPrev;
  10.     //释放pos结点
  11. 	free(pos);
  12. 	pos = NULL;
  13. }

11.双链表的销毁 

  1. //双向带头循环链表的销毁
  2. void ListDestroy(LTNode* phead)
  3. {
  4.     //在销毁链表的时候，逐个销毁，销毁前一个，必须要保存下一个结点的地址
  5. 	assert(phead);
  6. 	LTNode* cur = phead->next;
  7. 	while (cur != phead)
  8. 	{
  9. 		LTNode* next = cur->next;
  10. 		free(cur);
  11. 		cur = next;
  12. 	}
  13. 	free(phead);
  14. 	phead = NULL;
  15. }

四、源代码 

List.h

  1. #pragma once
  2.  
  3. #include <stdio.h>
  4. #include <assert.h>
  5. #include <stdlib.h>
  6.  
  7. typedef int LTDataType;
  8.  
  9. typedef struct ListNode
  10. {
  11. 	LTDataType Data;
  12. 	struct ListNode* next;
  13. 	struct ListNode* prev;
  14. }LTNode;
  15.  
  16. //双向带头循环链表的初始化
  17. LTNode* ListInit();
  18.  
  19. //双向带头循环链表的打印
  20. void ListPrint(LTNode* phead);
  21.  
  22. //增容函数
  23. LTNode* BuyListNode(LTDataType x);
  24.  
  25. //双向带头循环链表的尾插
  26. void ListPushBack(LTNode* phead, LTDataType x);
  27.  
  28. //双向带头循环链表的尾删
  29. void ListPopBack(LTNode* phead);
  30.  
  31. //双向带头循环链表的头插
  32. void ListPushFront(LTNode* phead, LTDataType x);
  33.  
  34. //双向带头循环链表的头删
  35. void ListPopFront(LTNode* phead);
  36.  
  37. //双向带头循环链表的查找
  38. LTNode* ListFind(LTNode* phead, LTDataType x);
  39.  
  40. //双向带头循环链表pos位置之前插入
  41. void ListInsert(LTNode* pos, LTDataType x);
  42.  
  43. //双向带头循环链表pos位置删除
  44. void ListErase(LTNode* pos);
  45.  
  46. //双向带头循环链表的销毁
  47. void ListDestroy(LTNode* phead);

List.c

  1. #include "List.h"
  2.  
  3. //双向带头循环链表的初始化
  4. LTNode* ListInit()
  5. {
  6. 	LTNode* phead = (LTNode*)malloc(sizeof(LTNode));//创建头结点
  7. 	phead->next = phead;//后继指针指向头
  8. 	phead->prev = phead;//前驱指针指向头
  9. 	return phead;
  10. }
  11.  
  12. //双向带头循环链表的打印
  13. void ListPrint(LTNode* phead)
  14. {
  15. 	assert(phead);
  16. 	LTNode* cur = phead->next;
  17. 	while (cur != phead)
  18. 	{
  19. 		printf("%d->", cur->Data);
  20. 		cur = cur->next;
  21. 	}
  22. 	printf("\n");
  23. }
  24.  
  25. //增容函数
  26. LTNode* BuyListNode(LTDataType x)
  27. {
  28. 	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
  29. 	if (newnode == NULL)
  30. 	{
  31. 		printf("malloc fail\n");
  32. 		exit(-1);
  33. 	}
  34. 	newnode->Data = x;
  35. 	newnode->next = NULL;
  36. 	newnode->prev = NULL;
  37. 	return newnode;
  38. }
  39.  
  40. //双向带头循环链表的尾插
  41. void ListPushBack(LTNode* phead, LTDataType x)
  42. {
  43. 	assert(phead);
  44. 	LTNode* tail = phead->prev;
  45. 	LTNode* newnode = BuyListNode(x);
  46. 	tail->next = newnode;
  47. 	newnode->prev = tail;
  48. 	newnode->next = phead;
  49. 	phead->prev = newnode;
  50. }
  51.  
  52. //双向带头循环链表的尾删
  53. void ListPopBack(LTNode* phead)
  54. {
  55. 	assert(phead);
  56. 	assert(phead->next != phead);
  57. 	LTNode* tail = phead->prev;
  58. 	LTNode* tailprev = tail->prev;
  59. 	free(tail);
  60. 	tailprev->next = phead;
  61. 	phead->prev = tailprev;
  62. 	//ListErase(phead->prev);//尾删就相当于复用Erase这个函数
  63. }
  64.  
  65. //双向带头循环链表的头插
  66. void ListPushFront(LTNode* phead, LTDataType x)
  67. {
  68. 	assert(phead);
  69. 	LTNode* newnode = BuyListNode(x);
  70. 	LTNode* next = phead->next;
  71. 	phead->next = newnode;
  72. 	newnode->prev = phead;
  73. 	newnode->next = next;
  74. 	next->prev = newnode;
  75. 	//ListInsert(phead->next, x);
  76. }
  77.  
  78. //双向带头循环链表的头删
  79. void ListPopFront(LTNode* phead)
  80. {
  81. 	assert(phead);
  82. 	assert(phead->next != phead);
  83. 	LTNode* next = phead->next;
  84. 	LTNode* nextNext = next->next;
  85. 	phead->next = next->next;
  86. 	nextNext->prev = phead;
  87. }
  88.  
  89. //双向带头循环链表的查找
  90. LTNode* ListFind(LTNode* phead, LTDataType x)
  91. {
  92. 	assert(phead);
  93. 	LTNode* cur = phead->next;
  94. 	while (cur != phead)
  95. 	{
  96. 		if (cur->Data == x)
  97. 		{
  98. 			return cur;
  99. 		}
  100. 		cur = cur->next;
  101. 	}
  102. 	return NULL;
  103. }
  104.  
  105. //双向带头循环链表pos位置之前插入
  106. void ListInsert(LTNode* pos, LTDataType x)
  107. {
  108. 	assert(pos);
  109. 	LTNode* posPrev = pos->prev;
  110. 	LTNode* newnode = BuyListNode(x);
  111. 	posPrev->next = newnode;
  112. 	newnode->prev = posPrev;
  113. 	newnode->next = pos;
  114. 	pos->prev = newnode;
  115. }
  116.  
  117. //双向带头循环链表pos位置删除
  118. void ListErase(LTNode* pos)
  119. {
  120. 	assert(pos);
  121. 	LTNode* posPrev = pos->prev;
  122. 	LTNode* posNext = pos->next;
  123. 	posPrev->next = posNext;
  124. 	posNext->prev = posPrev;
  125. 	free(pos);
  126. 	pos = NULL;
  127. }
  128.  
  129. //双向带头循环链表的销毁
  130. void ListDestroy(LTNode* phead)
  131. {
  132. 	assert(phead);
  133. 	LTNode* cur = phead->next;
  134. 	while (cur != phead)
  135. 	{
  136. 		LTNode* next = cur->next;
  137. 		free(cur);
  138. 		cur = next;
  139. 	}
  140. 	free(phead);
  141. 	phead = NULL;
  142. }

test.c

  1. #include "List.h"
  2.  
  3.  
  4. void TestList1()
  5. {
  6. 	LTNode* plist = ListInit();
  7. 	ListPushBack(plist, 5);
  8. 	ListPushBack(plist, 6);
  9. 	ListPushBack(plist, 7);
  10. 	ListPushBack(plist, 8);
  11. 	ListPrint(plist);
  12. 	ListPopBack(plist);
  13. 	ListPrint(plist);
  14.  
  15. 	ListPushFront(plist, 4);
  16. 	ListPushFront(plist, 3);
  17. 	ListPushFront(plist, 2);
  18. 	ListPushFront(plist, 1);
  19. 	ListPrint(plist);
  20. 	//ListPopFront(plist);
  21. 	//ListPopFront(plist);
  22. 	//ListPrint(plist);
  23.  
  24. 	LTNode* ret = ListFind(plist, 4);
  25. 	ListInsert(ret, 30);
  26. 	ListPrint(plist);
  27. 	ListDestroy(plist);
  28. 	plist = NULL;
  29. }
  30.  
  31. int main()
  32. {
  33. 	TestList1();
  34. 	return 0;
  35. }

五、顺序表和双向链表的总结

1.顺序表的优点与缺点

优点：（可以使用下标访问 ）     

1.支持随机访问；需要随机访问结构支持算法可以很好的适用；

        2.cpu高速缓存命中率更高 

缺点：

        1.头部、中部插入删除数据时间效率低。O(N)

        2.连续的物理空间，空间不够需要增容；

                ①、增容有一定程度消耗

                ②、为了避免频繁增容，一般我们都按倍数去增，用不完可能存在一定的空间浪费

2. 双向链表的优点与缺点

优点：（不可以使用下标访问 ）

        1.任意位置插入，效率高；o(1)

        2.按需申请释放空间；

缺点：

        1.不支持随机访问；意味着：一些排序，二分查找在这种结构上不适用；

        2.链表存储一个值，同时要存储链接指针，也有一定的消耗；

        3.cpu高速缓存命中率更低；

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

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

  

闽ICP备14008679号