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

链表之带头双向循环链表（C语言版）_链表的初始化函数的定义

作者：Monodyee | 2024-05-31 20:05:02

赞

踩

链表的初始化函数的定义

我们之前已经介绍过链表的知识了，这里我们直接开始实现带头双向循环链表

数据结构之单链表（不带头单向非循环链表）-CSDN博客

第一步：定义结构体

  1. //定义结构体
  2. typedef int SLTDateType;
  3. typedef struct Listnode
  4. {
  5. 	SLTDateType date;
  6. 	struct Listnode* prev;
  7. 	struct Listnode* next;
  8. }SL;

注意：我们这里要两个指针，一个指向链表前一个，一个指向链表下一个。

第二步：实现开辟空间函数

  1. //开辟空间函数定义
  2. SL* BuyListNode(SLTDateType x)
  3. {
  4. 	SL* nownode = (SL*)malloc(sizeof(SL));//动态开辟一个结构体大小的空间
  5. 	nownode->date = x;//将开辟的空间中结构体成员date赋值为x
  6. 	nownode->next = NULL;//将该结构体成员尾指针置为空
  7. 	nownode->prev = NULL;//将该结构体成员头指针置为空
  8. 	return nownode;//返回该结构体地址
  9. }

第三步：实现初始化函数

  1. //初始化函数定义
  2. SL* ListInit()
  3. {
  4. 	//该函数是创造一个head结构体放在链表的开头，满足带头链表
  5. 	SL* phead = BuyListNode(0);//将该结构开辟空间，并且将成员date赋值0
  6. 	phead->next = phead;//将phead的尾指针指向自己
  7. 	phead->prev = phead;//将phead的头指针指向自己
  8. 	return phead;//返回该结构体地址
  9. }

第四步：实现双向链表打印

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

第五步：实现四大接口（头删 尾删  头插   尾插）

  1. //双向链表尾插定义
  2. void ListPushBack(SL* phead, SLTDateType x)
  3. {
  4. 	/*尾插的实现可以分成四步：
  5. 	1.将链表的最后一个元素尾指针从指向链表第一个元素变成指向开辟的结构体
  6. 	2.将开辟的结构体头指针指向链表最后一个元素
  7. 	3.将链表的第一个元素头指针从指向链表最后一个元素变成指向开辟的结构体
  8. 	4.将开辟的结构体尾指针指向链表第一个元素
  9. 	*/
  10. 	assert(phead);
  11. 	SL* tail = phead->prev;//定义一个结构体指针指向头位置的头指针指向的位置，即为链表的最后一个元素
  12. 	SL* nownode = BuyListNode(x);//开辟一个结构体空间
  13. 	tail->next = nownode;//将tail结构体尾指针指向开辟的结构体的位置
  14. 	nownode->prev = tail;//将开辟的结构体的头指针指向tail的位置，即为链表的最后一个元素
  15. 	nownode->next = phead;//将开辟的结构体的尾指针指向链表的开头，即为phead
  16. 	phead->prev = nownode;//将phead的头指针指向开辟的结构体nownode
  17. }
  1. // 双向链表头插定义
  2. void ListPushFront(SL* phead, SLTDateType x)
  3. {
  4. 	assert(phead);//检查
  5. 	assert(phead->next!=NULL);//检查
  6. 	SL* nownode = BuyListNode(x);
  7. 	SL* next = phead->next;
  8. 	phead->next = nownode;
  9. 	nownode->prev = phead;
  10. 	nownode->next = next;
  11. 	next->prev = nownode;
  12. }
  1. // 双向链表尾删定义
  2. void ListPopBack(SL* phead)
  3. {
  4. 	assert(phead);//检查
  5. 	assert(phead->next != NULL);//检查
  6. 	SL* first = phead->prev;
  7. 	SL* second =first->prev;
  8. 	phead->prev = second;
  9. 	second->next = phead;
  10. 	free(first);//释放first
  11. 	first = NULL;//指针置为空
  12. }
  1. // 双向链表头删定义
  2. void ListPopFront(SL* phead)
  3. {
  4. 	assert(phead);
  5. 	SL* first = phead->next;
  6. 	SL* second = first->next;
  7. 	phead->next =second ;
  8. 	second->prev =phead ;
  9. 	free(first);
  10. 	first = NULL;
  11. }

大家可以自己画图理解下，我的第一个注释写的详细

下面我们检验代码：

  1. #include "SList.h"
  2. void test1()
  3. {
  4. 	//我们实现尾插1 2 3，再头插3 2 1，然后打印观察
  5. 	// 再头删去 3 2 ，尾删 3 2,然后打印观察
  6. 	//调用函数测试
  7. 	SL* plist = ListInit();
  8. 	//双向链表尾插调用
  9. 	ListPushBack(plist, 1);
  10. 	ListPushBack(plist, 2);
  11. 	ListPushBack(plist, 3);
  12. 	// 双向链表头插调用
  13. 	ListPushFront(plist,3);
  14. 	ListPushFront(plist,2);
  15. 	ListPushFront(plist,1);
  16. 	//双向链表打印调用
  17. 	ListPrint(plist);
  18. 	// 双向链表头删调用
  19. 	ListPopFront(plist);
  20. 	ListPopFront(plist);
  21. 	// 双向链表尾删调用
  22. 	ListPopBack(plist);
  23. 	ListPopBack(plist);
  24. 	// 双向链表打印调用
  25. 	ListPrint(plist);
  26. }
  27. int main()
  28. {
  29. 	test1();
  30. 	return 0;
  31. }

结果：

噢耶，对了，现在我们可以继续下一步了！

第六步：实现特殊接口

  1. // 双向链表查找定义
  2. SL* ListFind(SL* phead, SLTDateType x)
  3. {
  4. 	assert(phead);
  5. 	SL* cur = phead->next;
  6. 	while (cur != phead)
  7. 	{
  8. 		if (cur->date ==x )
  9. 		{
  10. 			return cur;
  11. 		}
  12. 		cur = cur->next;
  13. 	}
  14. 	return NULL;
  15. }
  1. // 双向链表在pos的前面进行插入定义
  2. void ListInsert(SL* pos, SLTDateType x)
  3. {
  4. 	assert(pos);
  5. 	SL* first = pos->prev;
  6. 	SL* newnode = BuyListNode(x);
  7. 	first->next= newnode;
  8. 	newnode->prev=first;
  9. 	newnode->next=pos;
  10. 	pos->prev=newnode;
  11. }
  1. // 双向链表删除pos位置的结点定义
  2. void ListErase(SL* pos)
  3. {
  4. 	assert(pos);
  5. 	SL* first = pos->prev;
  6. 	SL* second = pos->next;
  7. 	first->next = second;
  8. 	second->prev = first;
  9. }
  1. // 双向链表销毁定义
  2. void ListDestory(SL* phead)
  3. {
  4. 	assert(phead);
  5. 	SL* cur = phead->next;
  6. 	while (cur != phead)
  7. 	{
  8. 		SL* cur2 = cur->next;
  9. 		free(cur);
  10. 		cur = cur2;
  11. 	}
  12. 	free(phead);
  13. 	phead = NULL;
  14. }

再次进行检查：

  1. void test2()
  2. {
  3. 	SL* plist = ListInit();
  4. 	//双向链表尾插调用
  5. 	ListPushBack(plist, 1);
  6. 	ListPushBack(plist, 2);
  7. 	ListPushBack(plist, 3);
  8. 	// 双向链表打印调用
  9. 	ListPrint(plist);
  10. 	SL* pos = ListFind(plist, 2);
  11. 	if(pos != NULL)
  12. 	{
  13. 		// 双向链表在pos的前面进行插入
  14. 		ListInsert(pos, 30);
  15. 		// 双向链表打印调用
  16. 		ListPrint(plist);
  17. 		// 双向链表删除pos位置的结点
  18. 		ListErase(pos);
  19. 		// 双向链表打印调用
  20. 		ListPrint(plist);
  21. 	}
  22. 	free(pos);
  23. 	pos = NULL;
  24. 	// 双向链表销毁
  25. 	ListDestory(plist);
  26. }
  27. int main()
  28. {
  29. 	//test1();
  30. 	test2();
  31. 	return 0;
  32. }

结果：

综上：我们成功实现了带头双向循环链表！

全部代码如下：

这个是SList.c文件

  1. #include "SList.h"
  2.  
  3. //开辟空间函数定义
  4. SL* BuyListNode(SLTDateType x)
  5. {
  6. 	SL* nownode = (SL*)malloc(sizeof(SL));//动态开辟一个结构体大小的空间
  7. 	if (nownode == NULL)
  8. 	{
  9. 		perror(nownode);
  10. 		exit(-1);
  11. 	}
  12. 	nownode->date = x;//将开辟的空间中结构体成员date赋值为x
  13. 	nownode->next = NULL;//将该结构体成员尾指针置为空
  14. 	nownode->prev = NULL;//将该结构体成员头指针置为空
  15. 	return nownode;//返回该结构体地址
  16. }
  17. //初始化函数定义
  18. SL* ListInit()
  19. {
  20. 	//该函数是创造一个head结构体放在链表的开头，满足带头链表
  21. 	SL* phead = BuyListNode(0);//将该结构开辟空间，并且将成员date赋值0
  22. 	phead->next = phead;//将phead的尾指针指向自己
  23. 	phead->prev = phead;//将phead的头指针指向自己
  24. 	return phead;//返回该结构体地址
  25. }
  26. // 双向链表打印定义
  27. void ListPrint(SL* phead)
  28. {
  29. 	assert(phead);
  30. 	SL* cur = phead->next;	
  31. 	while (cur != phead)
  32. 	{
  33. 		printf("%d ", cur->date);
  34. 		cur = cur->next;
  35. 	}
  36. 	printf("\n");
  37. }
  38. //双向链表尾插定义
  39. void ListPushBack(SL* phead, SLTDateType x)
  40. {
  41. 	/*尾插的实现可以分成四步：
  42. 	1.将链表的最后一个元素尾指针从指向链表第一个元素变成指向开辟的结构体
  43. 	2.将开辟的结构体头指针指向链表最后一个元素
  44. 	3.将链表的第一个元素头指针从指向链表最后一个元素变成指向开辟的结构体
  45. 	4.将开辟的结构体尾指针指向链表第一个元素
  46. 	*/
  47. 	assert(phead);
  48. 	SL* tail = phead->prev;//定义一个结构体指针指向头位置的头指针指向的位置，即为链表的最后一个元素
  49. 	SL* nownode = BuyListNode(x);//开辟一个结构体空间
  50. 	tail->next = nownode;//将tail结构体尾指针指向开辟的结构体的位置
  51. 	nownode->prev = tail;//将开辟的结构体的头指针指向tail的位置，即为链表的最后一个元素
  52. 	nownode->next = phead;//将开辟的结构体的尾指针指向链表的开头，即为phead
  53. 	phead->prev = nownode;//将phead的头指针指向开辟的结构体nownode
  54. }
  55. // 双向链表头插定义
  56. void ListPushFront(SL* phead, SLTDateType x)
  57. {
  58. 	assert(phead);//检查
  59. 	assert(phead->next!=NULL);//检查
  60. 	SL* nownode = BuyListNode(x);
  61. 	SL* next = phead->next;
  62. 	phead->next = nownode;
  63. 	nownode->prev = phead;
  64. 	nownode->next = next;
  65. 	next->prev = nownode;
  66. }
  67. // 双向链表尾删定义
  68. void ListPopBack(SL* phead)
  69. {
  70. 	assert(phead);//检查
  71. 	assert(phead->next != NULL);//检查
  72. 	SL* first = phead->prev;
  73. 	SL* second =first->prev;
  74. 	phead->prev = second;
  75. 	second->next = phead;
  76. 	free(first);//释放first
  77. 	first = NULL;//指针置为空
  78. }
  79. // 双向链表头删定义
  80. void ListPopFront(SL* phead)
  81. {
  82. 	assert(phead);
  83. 	SL* first = phead->next;
  84. 	SL* second = first->next;
  85. 	phead->next =second ;
  86. 	second->prev =phead ;
  87. 	free(first);
  88. 	first = NULL;
  89. }
  90. // 双向链表查找定义
  91. SL* ListFind(SL* phead, SLTDateType x)
  92. {
  93. 	assert(phead);
  94. 	SL* cur = phead->next;
  95. 	while (cur != phead)
  96. 	{
  97. 		if (cur->date ==x )
  98. 		{
  99. 			return cur;
  100. 		}
  101. 		cur = cur->next;
  102. 	}
  103. 	return NULL;
  104. }
  105. // 双向链表在pos的前面进行插入定义
  106. void ListInsert(SL* pos, SLTDateType x)
  107. {
  108. 	assert(pos);
  109. 	SL* first = pos->prev;
  110. 	SL* newnode = BuyListNode(x);
  111. 	first->next= newnode;
  112. 	newnode->prev=first;
  113. 	newnode->next=pos;
  114. 	pos->prev=newnode;
  115. }
  116. // 双向链表删除pos位置的结点定义
  117. void ListErase(SL* pos)
  118. {
  119. 	assert(pos);
  120. 	SL* first = pos->prev;
  121. 	SL* second = pos->next;
  122. 	first->next = second;
  123. 	second->prev = first;
  124. }
  125. // 双向链表销毁定义
  126. void ListDestory(SL* phead)
  127. {
  128. 	assert(phead);
  129. 	SL* cur = phead->next;
  130. 	while (cur != phead)
  131. 	{
  132. 		SL* cur2 = cur->next;
  133. 		free(cur);
  134. 		cur = cur2;
  135. 	}
  136. 	free(phead);
  137. 	phead = NULL;
  138. }

头文件：SList.h文件

  1. #pragma once
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <assert.h>
  5. //定义结构体
  6. typedef int SLTDateType;
  7. typedef struct Listnode
  8. {
  9. 	SLTDateType date;
  10. 	struct Listnode* prev;
  11. 	struct Listnode* next;
  12. }SL;
  13. //双向链开辟空间函数声明
  14. SL* BuyListNode(SLTDateType x);
  15. //双向链初始化函数声明
  16. SL* ListInit();
  17. // 双向链表打印声明
  18. void ListPrint(SL* phead);
  19. //双向链表尾插声明
  20. void ListPushBack(SL* phead, SLTDateType x);
  21. // 双向链表头插声明
  22. void ListPushFront(SL* plist, SLTDateType x);
  23. // 双向链表尾删声明
  24. void ListPopBack(SL* phead);
  25. // 双向链表头删声明
  26. void ListPopFront(SL* phead);
  27. // 双向链表查找声明
  28. SL* ListFind(SL* phead, SLTDateType x);
  29. // 双向链表在pos的前面进行插入声明
  30. void ListInsert(SL* pos, SLTDateType x);
  31. // 双向链表删除pos位置的结点声明
  32. void ListErase(SL* pos);
  33. // 双向链表销毁声明
  34. void ListDestory(SL* phead);

下面是我们的调试文件:test.c

  1. #include "SList.h"
  2. void test1()
  3. {
  4. 	//我们实现尾插1 2 3，再头插3 2 1，然后打印观察
  5. 	// 再头删去 3 2 ，尾删 3 2,然后打印观察
  6. 	//调用函数测试
  7. 	SL* plist = ListInit();
  8. 	//双向链表尾插调用
  9. 	ListPushBack(plist, 1);
  10. 	ListPushBack(plist, 2);
  11. 	ListPushBack(plist, 3);
  12. 	// 双向链表头插调用
  13. 	ListPushFront(plist,3);
  14. 	ListPushFront(plist,2);
  15. 	ListPushFront(plist,1);
  16. 	//双向链表打印调用
  17. 	ListPrint(plist);
  18. 	// 双向链表头删调用
  19. 	ListPopFront(plist);
  20. 	ListPopFront(plist);
  21. 	// 双向链表尾删调用
  22. 	ListPopBack(plist);
  23. 	ListPopBack(plist);
  24. 	// 双向链表打印调用
  25. 	ListPrint(plist);
  26. }
  27. void test2()
  28. {
  29. 	SL* plist = ListInit();
  30. 	//双向链表尾插调用
  31. 	ListPushBack(plist, 1);
  32. 	ListPushBack(plist, 2);
  33. 	ListPushBack(plist, 3);
  34. 	// 双向链表打印调用
  35. 	ListPrint(plist);
  36. 	SL* pos = ListFind(plist, 2);
  37. 	if(pos != NULL)
  38. 	{
  39. 		// 双向链表在pos的前面进行插入
  40. 		ListInsert(pos, 30);
  41. 		// 双向链表打印调用
  42. 		ListPrint(plist);
  43. 		// 双向链表删除pos位置的结点
  44. 		ListErase(pos);
  45. 		// 双向链表打印调用
  46. 		ListPrint(plist);
  47. 	}
  48. 	free(pos);
  49. 	pos = NULL;
  50. 	// 双向链表销毁
  51. 	ListDestory(plist);
  52. }
  53. int main()
  54. {
  55. 	//test1();
  56. 	test2();
  57. 	return 0;
  58. }

希望大家坚持学下去，在链表这里你可以发现无穷的乐趣，当然建议大家链表这里还是多刷题，这样才能帮助我们更好理解它。

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

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

  

闽ICP备14008679号