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

数据结构——带头双向循环链表（c语言实现）

作者：我家小花儿 | 2024-06-27 11:48:16

赞

踩

数据结构——带头双向循环链表（c语言实现）

目录

 

1.单链表和双向链表对比

2.双向链表实现

2.1 创建新节点

2.2 链表初始化 

2.3 尾插 

2.4 头插 

2.5 尾删 

2.6 头删 

2.7 查找 

2.8 指定位置后插入数据 

2.9 删除指定节点 

2.10 销毁链表

2.11 打印链表 

 前言：

     我们在前几期详细地讲解了不带头单向不循环链表（单链表），使用它的底层代码实现了一个简单的通讯录项目，也介绍了链表分为八种，但是其中最常用的只有两种：（1）不带头单向不循环链表，（2）带头双向循环链表，今天我们要讲解的就是第二种带头双向循环链表

1.单链表和双向链表对比

在介绍双向链表之前，我们先来对比一下单链表和双向链表的区别。

这是单链表：

这是双向链表：

 

        双向链表的特点是每相邻两个节点都相互连接，每个节点都有三个部分，包括data，next，prev，其中data负责存放数据，next负责存放后一个节点的地址，prev负责存放前一个节点的地址，最后一个节点和头节点（哨兵位）相互连接，形成了一个循环双向链表，那么什么是哨兵位呢，哨兵位就是双向链表的头节点，它不存放有效数据，只存放第一个有序数据的节点的地址和最后一个有序数据节点的地址。 

       那么它们的区别是什么呢？

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

2.双向链表实现

  介绍完了双向链表的区别我们接下来就要着手开始用代码实现双向链表了。由于代码可能较多，我们将双向链表的代码分成了三个文件，分别是List.h,List.c和tste.c文件：

在list.h文件中，我们要包含我们会用到的头文件，其他文件只要包含List.h文件就可以使用这些头文件了：

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include<stdio.h>
  3. #include<stdlib.h>
  4. #include<assert.h>

双向链表的实现也是在此文件中，由于我们不知道将来使用链表会存放什么样的数据，所以我们使用typedef对这个数据的类型改名，我们实现链表使用的是int类型，所以我们对int改名：

typedef int ListNodeData;

链表中的next和prev链表是用来存放节点地址的，所以它们为指针类型，而为了方便使用，我们将链表使用typedf改名，下面是双向链表实现：

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

2.1 创建新节点

创建新节点我们使用malloc从堆申请一块LTNode类型大小的内存，它的data类型用来存放将来要插入的数据，prev和next指针在创建这个节点时先让它指向自己，如果要创建新节点，就调用这个函数，它会返回一个指向这块空间的指针：

  1. LTNode* LTBuyNode(ListNodeData x)
  2. {
  3. 	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
  4. 	if (newnode == NULL)
  5. 	{
  6. 		perror("malloc fail");
  7. 		exit(1);
  8. 	}
  9. 	newnode->data = x;
  10. 	newnode->next = newnode;
  11. 	newnode->prev = newnode;
  12.  
  13. 	return newnode;
  14.  
  15. }//创建一个新节点

2.2 链表初始化 

 

在最初创建一个链表时，它的内部为空，什么也没有，我们初始化应该此链表让它至少有一个哨兵位：

  1. void LTInit(LTNode** pphead)
  2. {
  3. 	assert(pphead);
  4. 	*pphead = LTBuyNode(-1);
  5.  
  6.  
  7. }//初始化

2.3 尾插 

尾插操作应该先创建一个新节点，插入顺序为：先让新节点的prev指针指向最后一个节点，然后让新节点的next指针指向哨兵位实现循环，以上的两步都不会影响旧节点，接下来就是让最后一个节点的next指针指向这个新节点，然后让哨兵位的prev指针指向新节点完成尾插：

具体实现代码为：

  1. void LTPushBack(LTNode* phead, ListNodeData x)
  2. {
  3. 	assert(phead);
  4. 	LTNode* newnode = LTBuyNode(x);
  5.  
  6. 	newnode->next = phead;
  7. 	newnode->prev = phead->prev;
  8.  
  9. 	phead->prev->next = newnode;
  10. 	phead->prev = newnode;
  11. }//尾插

2.4 头插 

     头插操作并不是将新节点放在哨兵位之前，而是将新节点放在第一个有效数据节点之前，所以我们应该将新节点放在哨兵位的后面。先创建一个新节点，让新节点的prev指针指向哨兵位，让它的next指针指向哨兵位的next指向的节点，以上两步不会影响任何节点，做完这两步后，先让哨兵位后面那个节点的prev指针指向新节点，然后让哨兵位的next指针指向新节点，这两步不能调换顺序，否则会找不到哨兵位后面那个节点，下面是代码实现：

  1. void LTPushFront(LTNode* phead, ListNodeData x)
  2. {
  3. 	assert(phead);
  4. 	LTNode* newnode = LTBuyNode(x);
  5.  
  6. 	newnode->next = phead->next;
  7. 	newnode->prev = phead;
  8.  
  9. 	phead->next->prev = newnode;
  10. 	phead->next = newnode;
  11.  
  12. }//头插

2.5 尾删 

   执行删除操作之前我们应该先判断这个链表除哨兵位之外有没有其他节点，如果没有，就无法删除，而尾删操作也比较简单，只需要让尾节点的前一个节点的next指针指向哨兵位，然后让哨兵位的prev指针指向位尾节点，以上过程需要创建一个新变量，否则无法找到我们要删除的节点，接着释放掉尾节点后置空就可以了：

  1. void LTPopBack(LTNode* phead)
  2. {
  3. 	assert(phead&&phead->next);
  4. 	LTNode* del = phead->prev;
  5.  
  6. 	del->prev->next = del->next;
  7. 	del->next->prev = del->prev;
  8. 	free(del);
  9. 	del = NULL;
  10.  
  11. }//尾删

画图演示：

 

2.6 头删 

  头删操作与尾删类似，如果没有两个及以上节点的话无法执行删除操作，头删要删除的是哨兵位后面那个节点，所以我们先创建一个指针存放我们要删除节点的地址，将哨兵位的next指针指向我们要删除节点的下一个节点，然后将我们要删除节点的下一个节点的prev指针指向哨兵位，完成这些操作后释放我们要删除的节点然后置空：

  1. void LTPopFront(LTNode* phead)
  2. {
  3. 	assert(phead && phead->next);
  4. 	LTNode* del = phead->next;
  5.  
  6. 	phead->next = del->next;
  7. 	del->next->prev = phead;
  8. 	free(del);
  9. 	del = NULL;
  10. }//头删

2.7 查找 

如果我们要查找一个节点，应该先判断链表是否为空，然后将我们要查找的节点的数据与链表中节点的数据一一对比，如果数据内容相同，说明找到了，将这个节点返回，如果循环一圈还没有找到，说明链表中不存在这样的节点，返回应一个空指针：

  1. LTNode* LTFind(LTNode* phead, ListNodeData x)
  2. {
  3. 	assert(phead && phead->next);
  4. 	LTNode* pcur = phead->next;
  5. 	while (pcur != phead)
  6. 	{
  7. 		if (pcur->data == x)
  8. 		{
  9. 			return pcur;
  10. 		}
  11. 		pcur = pcur->next;
  12. 	}
  13. 	return NULL;
  14. }//查找函数

2.8 指定位置后插入数据 

我们可以先调用查找函数，然后调用它返回的节点，试着在它的后面插入数据，而它的操作与头插非常相像，只是将哨兵位改成了我们指定的节点：

  1. void LTInsertAfter(LTNode* phead, LTNode* pop, ListNodeData x)
  2. {
  3. 	assert(phead&&pop);
  4. 	LTNode* newnode = LTBuyNode(x);
  5. 	newnode->prev = pop;
  6. 	newnode->next = pop->next;
  7.  
  8. 	pop->next->prev = newnode;
  9. 	pop->next = newnode;
  10. }//指定节点后插入数据

2.9 删除指定节点 

删除节点我们需要先判断链表中是否有两个及以上节点，否则无法删除，删除指定节操作我们先将指定节点的前一个节点的next指向我们指定节点的下一个节点，然后将指定节点的下一个节点的prev指针指向指定节点的前一个节点，这个过程不需要创建中间变量，因为我们有指定节点的地址：

  1. void LTErase(LTNode* phead, LTNode* pop)
  2. {
  3. 	assert(phead && phead->next);
  4. 	pop->next->prev = pop->prev;
  5. 	pop->prev->next = pop->next;
  6.  
  7. 	free(pop);
  8. 	pop = NULL;
  9.  
  10. }//指定删除节点

2.10 销毁链表

我们链表的每一个节点都是使用malloc函数手动在堆上申请的，需要我们手动释放：

  1. void LTDestroy(LTNode* phead)
  2. {
  3. 	assert(phead);
  4. 	LTNode* pcur = phead->next;
  5. 	while (pcur != phead)
  6. 	{
  7. 		LTNode* next = pcur->next;
  8. 		free(pcur);
  9. 		pcur = next;
  10. 	}
  11.  
  12. }//销毁链表
  13.

2.11 打印链表 

指行这么多插入删除操作我们如果测试的话就使用这个函数打印出来，而打印函数只需要循环打印这个链表一次就可以了：

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

接下来我们使用这个函数来测试一下我们的方法：

可以看到我们的方法都没有问题，那么这期的双向链表就到此结束啦，我将代码放在下面，感兴趣的小伙伴可以试试哦。

List.h :

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include<stdio.h>
  3. #include<stdlib.h>
  4. #include<assert.h>
  5.  
  6. typedef int ListNodeData;
  7. typedef struct ListNode
  8. {
  9. 	ListNodeData data;
  10. 	struct ListNode* prev;
  11. 	struct ListNode* next;
  12.  
  13. }LTNode;
  14.  
  15.  
  16.  
  17.  
  18. LTNode* LTFind(LTNode* phead, ListNodeData x);//查找
  20. void LTInit(LTNode** pphead);//初始化
  21.  
  22. void LTPushBack(LTNode* phead, ListNodeData x);
  23. //尾插
  24.  
  25. void LTPrint(LTNode* phead);//打印链表
  26.  
  27. void LTPushFront(LTNode* phead, ListNodeData x);
  28. //头插
  29.  
  30. void LTPopBack(LTNode* phead);//尾删
  31.  
  32. void LTPopFront(LTNode* phead);//头删
  33.  
  34. void LTInsertAfter(LTNode* phead, LTNode* pop, ListNodeData x);
  35. //指定节点后删除
  36.  
  37. void LTErase(LTNode* phead, LTNode* pop);
  38. //指定位置删除
  39.  
  40. void LTDestroy(LTNode* phead);
  41. //销毁链表

List.c :

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include"List.h"
  3.  
  4. LTNode* LTBuyNode(ListNodeData x)
  5. {
  6. 	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
  7. 	if (newnode == NULL)
  8. 	{
  9. 		perror("malloc fail");
  10. 		exit(1);
  11. 	}
  12. 	newnode->data = x;
  13. 	newnode->next = newnode;
  14. 	newnode->prev = newnode;
  15.  
  16. 	return newnode;
  17.  
  18. }//创建一个新节点
  19.  
  20. LTNode* LTFind(LTNode* phead, ListNodeData x)
  21. {
  22. 	assert(phead && phead->next);
  23. 	LTNode* pcur = phead->next;
  24. 	while (pcur != phead)
  25. 	{
  26. 		if (pcur->data == x)
  27. 		{
  28. 			return pcur;
  29. 		}
  30. 		pcur = pcur->next;
  31. 	}
  32. 	return NULL;
  33. }//查找函数
  34.  
  35. void LTInit(LTNode** pphead)
  36. {
  37. 	assert(pphead);
  38. 	*pphead = LTBuyNode(-1);
  39.  
  40.  
  41. }//初始化
  42.  
  43. void LTPushBack(LTNode* phead, ListNodeData x)
  44. {
  45. 	assert(phead);
  46. 	LTNode* newnode = LTBuyNode(x);
  47.  
  48. 	newnode->next = phead;
  49. 	newnode->prev = phead->prev;
  50.  
  51. 	phead->prev->next = newnode;
  52. 	phead->prev = newnode;
  53. }//尾插
  54.  
  55. void LTPushFront(LTNode* phead, ListNodeData x)
  56. {
  57. 	assert(phead);
  58. 	LTNode* newnode = LTBuyNode(x);
  59.  
  60. 	newnode->next = phead->next;
  61. 	newnode->prev = phead;
  62.  
  63. 	phead->next->prev = newnode;
  64. 	phead->next = newnode;
  65.  
  66. }//头插
  67.  
  68. void LTPopBack(LTNode* phead)
  69. {
  70. 	assert(phead&&phead->next);
  71. 	LTNode* del = phead->prev;
  72.  
  73. 	del->prev->next = del->next;
  74. 	del->next->prev = del->prev;
  75. 	free(del);
  76. 	del = NULL;
  77.  
  78. }//尾删
  79.  
  80. void LTPopFront(LTNode* phead)
  81. {
  82. 	assert(phead && phead->next);
  83. 	LTNode* del = phead->next;
  84.  
  85. 	phead->next = del->next;
  86. 	del->next->prev = phead;
  87. 	free(del);
  88. 	del = NULL;
  89. }//头删
  90.  
  91. void LTInsertAfter(LTNode* phead, LTNode* pop, ListNodeData x)
  92. {
  93. 	assert(phead&&pop);
  94. 	LTNode* newnode = LTBuyNode(x);
  95. 	newnode->prev = pop;
  96. 	newnode->next = pop->next;
  97.  
  98. 	pop->next->prev = newnode;
  99. 	pop->next = newnode;
  100. }//指定节点后插入数据
  101.  
  102. void LTErase(LTNode* phead, LTNode* pop)
  103. {
  104. 	assert(phead && phead->next);
  105. 	pop->next->prev = pop->prev;
  106. 	pop->prev->next = pop->next;
  107.  
  108. 	free(pop);
  109. 	pop = NULL;
  110.  
  111. }//指定删除节点
  112.  
  113.  
  114.  
  115.  
  116. void LTPrint(LTNode* phead)
  117. {
  118. 	assert(phead);
  119. 	LTNode* pcur = phead->next;
  120. 	while (pcur != phead)
  121. 	{
  122. 		printf("%d->", pcur->data);
  123. 		pcur = pcur->next;
  124. 	}
  125. 	printf("NULL\n");
  126.  
  127. }//打印
  128.  
  129. void LTDestroy(LTNode* phead)
  130. {
  131. 	assert(phead);
  132. 	LTNode* pcur = phead->next;
  133. 	while (pcur != phead)
  134. 	{
  135. 		LTNode* next = pcur->next;
  136. 		free(pcur);
  137. 		pcur = next;
  138. 	}
  139.  
  140. }//销毁链表
  141.

test.c :

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include"List.h"
  3. void test01()
  4. {
  5. 	LTNode* plist = NULL;
  6.     LTInit(&plist);
  7. 	printf("尾插\n");
  8. 	LTPushBack(plist, 1);
  9. 	LTPushBack(plist, 2);
  10. 	LTPushBack(plist, 3);
  11. 	LTPrint(plist);
  12. 	printf("头插\n");
  13. 	LTPushFront(plist, 0);
  14. 	LTPrint(plist);
  15.  
  16. 	/*printf("尾删\n");
  17. 	LTPopBack(plist);
  18. 	LTPopBack(plist);
  19. 	LTPrint(plist);*/
  20. 	printf("头删\n");
  21. 	LTPopFront(plist);
  22. 	LTPopFront(plist);
  23. 	LTPrint(plist);
  24.  
  25. 	printf("在3后面插入数据:\n");
  26. 	LTNode* Find = LTFind(plist, 3);
  27. 	/*if (Find == NULL)
  28. 	{
  29. 		printf("找不到！\n");
  30. 	}
  31. 	else
  32. 	{
  33. 		printf("找到了\n");
  34. 	}*/
  35. 	LTInsertAfter(plist, Find, 56);
  36. 		LTPrint(plist);
  37.  
  38. 		printf("删除指定节点3：\n");
  39. 		LTErase(plist, Find);
  40. 		LTPrint(plist);
  41. 		printf("销毁链表\n");
  42. 		LTDestroy(plist);
  43. 		plist = NULL;
  44. 		
  45. 		
  46.  
  47.  
  48.  
  49.  
  50.  
  51. }
  52.  
  53. int main()
  54. {
  55. 	test01();
  56. 	return 0;
  57. }

 

 

 

 

 

 

 

 

 

 

 

 

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

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

  

闽ICP备14008679号