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

【数据结构】单链表（C语言）

作者：你好赵伟 | 2024-06-15 19:56:43

赞

踩

【数据结构】单链表（C语言）

在数据结构和算法中，链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。在C语言中，我们可以使用指针来实现单向链表。下面将详细讲述如何利用C语言实现单向链表。 

1.单链表的概念和结构

概念：链表是⼀种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。

 

链表的结构跟火车车厢相似，淡季时车次的⻋厢会相应减少，旺季时车次的车厢会额外增加几节。只需要将火车里的某节车厢去掉/加上，不会影响其他⻋厢，每节车厢都是独立存在的。
车厢是独立存在的，且每节车厢都有车门。想象⼀下这样的场景，假设每节车厢的车门都是锁上的状态，需要不同的钥匙才能解锁，每次只能携带⼀把钥匙的情况下如何从车头走到车尾？
最简单的做法：每节车厢⾥都放⼀把下⼀节车厢的钥匙。
在链表里，每节“车厢”是什么样的呢？
与顺序表不同的是，链表里的每节"车厢"都是独立申请下来的空间，我们称之为“结点/节点” 节点的组成主要有两个部分：当前节点要保存的数据和保存下⼀个节点的地址（指针变量）。
图中指针变量 plist保存的是第⼀个节点的地址，我们称plist此时“指向”第⼀个节点，如果我们希望plist“指向”第⼆个节点时，只需要修改plist保存的内容为0x0012FFA0。
为什么还需要指针变量来保存下⼀个节点的位置？
链表中每个节点都是独立申请的（即需要插⼊数据时才去申请⼀块节点的空间），我们需要通过指针变量来保存下⼀个节点位置才能从当前节点找到下⼀个节点。

2. 单链表的实现 

2.1 定义节点结构体

  结合前面学到的结构体知识，我们可以给出每个节点对应的结构体代码：
         
  1. struct SListNode
  2. {
  3.      int data; //节点数据
  4.      struct SListNode* next; //指针变量⽤保存下⼀个节点的地址
  5. };
假设当前保存的节点为整型：当我们想要保存⼀个整型数据时，实际是向操作系统申请了⼀块内存，这个内存不仅要保存整型数据，也需要保存下⼀个节点的地址（当下⼀个节点为空时保存的地址为空）。
当我们想要从第⼀个节点走到最后⼀个节点时，只需要在前⼀个节点拿上下⼀个节点的地址（下⼀个节点的钥匙）就可以了。

2.2 遍历链表实现打印

给定的链表结构中，如何实现节点从头到尾的打印？
思考：当我们想保存的数据类型为字符型、浮点型或者其他自定义的类型时，该如何修改？
补充说明：
1、链式结构在逻辑上是连续的，在物理结构上不⼀定连续
2、节点⼀般是从堆上申请的
3、从堆上申请来的空间，是按照⼀定策略分配出来的，每次申请的空间可能连续，可能不连续

2.3 创建新的节点

实现创建新的节点的函数：

  1. SLTNode* SLTBuyNode(SLTDataType x)
  2. {
  3. 	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
  4. 	if (newnode == NULL)
  5. 	{
  6. 		perror("malloc fail!");
  7. 		exit(1);
  8. 	}
  9. 	newnode->data = x;
  10. 	newnode->next = NULL;
  11.  
  12. 	return newnode;
  13. }

2.4 实现尾插

实现在链表的尾部插入节点的函数：

  1. //尾插
  2. void SLTPushBack(SLTNode** pphead, SLTDataType x)
  3. {
  4. 	assert(pphead);
  5. 	//*pphead 就是指向第一个节点的指针
  6. 	//空链表和非空链表
  7. 	SLTNode* newnode = SLTBuyNode(x);
  8. 	if (*pphead == NULL)
  9. 	{
  10. 		*pphead = newnode;
  11. 	}
  12. 	else 
  13. 	{
  14. 		//找尾
  15. 		SLTNode* ptail = *pphead;
  16. 		while (ptail->next)
  17. 		{
  18. 			ptail = ptail->next;
  19. 		}
  20. 		//ptail指向的就是尾结点
  21. 		ptail->next = newnode;
  22. 	}
  23. }

2.5 实现头插

实现在链表的头部插入节点的函数：

  1. //头插
  2. void SLTPushFront(SLTNode** pphead, SLTDataType x)
  3. {
  4. 	assert(pphead);
  5. 	SLTNode* newnode = SLTBuyNode(x);
  6. 	//newnode *pphead
  7. 	newnode->next = *pphead;
  8. 	*pphead = newnode;
  9. }

2.6 实现尾删

实现在链表的尾部删除节点的函数：

  1. //尾删
  2. void SLTPopBack(SLTNode** pphead)
  3. {
  4. 	//链表不能为空
  5. 	assert(pphead && *pphead);
  6. 	//链表只有一个节点
  7. 	if ((*pphead)->next == NULL) //-> 优先级高于*
  8. 	{
  9. 		free(*pphead);
  10. 		*pphead = NULL;
  11. 	}
  12. 	else {
  13. 		//链表有多个节点
  14.  
  15. 		SLTNode* prev = *pphead;
  16. 		SLTNode* ptail = *pphead;
  17. 		while (ptail->next)
  18. 		{
  19. 			prev = ptail;
  20. 			ptail = ptail->next;
  21. 		}
  22. 		//prev ptail
  23. 		free(ptail);
  24. 		ptail = NULL;
  25. 		prev->next = NULL;
  26. 	}
  27. }

2.7 实现头删

实现在链表的头部删除节点的函数：

  1. //头删
  2. void SLTPopFront(SLTNode** pphead)
  3. {
  4. 	//链表不能为空
  5. 	assert(pphead && *pphead);
  6.  
  7. 	SLTNode* next = (*pphead)->next; //-> 优先级高于*
  8. 	free(*pphead);
  9. 	*pphead = next;
  10. }

2.8 实现查找

实现在链表的查找节点的函数：

  1. //查找
  2. SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
  3. {
  4. 	SLTNode* pcur = phead;
  5. 	while (pcur)//等价于pcur != NULL
  6. 	{
  7. 		if (pcur->data == x)
  8. 		{
  9. 			return pcur;
  10. 		}
  11. 		pcur = pcur->next;
  12. 	}
  13. 	//pcur == NULL
  14. 	return NULL;
  15. }

2.9 在指定位置之前实现插入数据

实现在指定位置之前实现插入节点的函数：

  1. //在指定位置之前插入数据
  2. void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
  3. {
  4. 	assert(pphead && *pphead);
  5. 	assert(pos);
  6. 	SLTNode* newnode = SLTBuyNode(x);
  7. 	//若pos == *pphead;说明是头插
  8. 	if (pos == *pphead)
  9. 	{
  10. 		SLTPushFront(pphead, x);
  11. 	}
  12. 	else {
  13. 		SLTNode* prev = *pphead;
  14. 		while (prev->next != pos)
  15. 		{
  16. 			prev = prev->next;
  17. 		}
  18. 		//prev -> newnode -> pos
  19. 		newnode->next = pos;
  20. 		prev->next = newnode;
  21. 	}
  22. }

2.10 在指定位置之后实现插入数据

实现在指定位置之后实现插入节点的函数：

  1. //在指定位置之后插入数据
  2. void SLTInsertAfter(SLTNode* pos, SLTDataType x)
  3. {
  4. 	assert(pos);
  5.  
  6. 	SLTNode* newnode = SLTBuyNode(x);
  7. 	//pos -> newnode -> pos->next
  8. 	newnode->next = pos->next;
  9. 	pos->next = newnode;
  10. }

2.11 删除pos节点

实现删除pos节点的函数：

  1. //删除pos节点
  2. void SLTErase(SLTNode** pphead, SLTNode* pos)
  3. {
  4. 	assert(pphead && *pphead);
  5. 	assert(pos);
  6. 	//pos是头结点/pos不是头结点
  7. 	if (pos == *pphead)
  8. 	{
  9. 		//头删
  10. 		SLTPopFront(pphead);
  11. 	}
  12. 	else {
  13. 		SLTNode* prev = *pphead;
  14. 		while (prev->next != pos)
  15. 		{
  16. 			prev = prev->next;
  17. 		}
  18. 		//prev pos pos->next
  19. 		prev->next = pos->next;
  20. 		free(pos);
  21. 		pos = NULL;
  22. 	}
  23. }

2.12 删除pos之后的节点

实现删除pos之后的节点的函数：

  1. //删除pos之后的节点
  2. void SLTEraseAfter(SLTNode* pos)
  3. {
  4. 	assert(pos && pos->next);
  5. 	SLTNode* del = pos->next;
  6. 	//pos del del->next
  7. 	pos->next = del->next;
  8. 	free(del);
  9. 	del = NULL;
  10. }

2.13 销毁链表

实现销毁链表的函数：

  1. //销毁链表
  2. void SListDesTroy(SLTNode** pphead)
  3. {
  4. 	assert(pphead && *pphead);
  5.  
  6. 	SLTNode* pcur = *pphead;
  7. 	while (pcur)
  8. 	{
  9. 		SLTNode* next = pcur->next;
  10. 		free(pcur);
  11. 		pcur = next;
  12. 	}
  13. 	//pcur
  14. 	*pphead = NULL;
  15. }

最后附全部代码如下：

  1. //SList.h
  2. #pragma once
  3. #include<stdio.h>
  4. #include<stdlib.h>
  5. #include<assert.h>
  6.  
  7. //定义节点的结构
  8. //数据 + 指向下一个节点的指针
  9. typedef int SLTDataType;
  10.  
  11. typedef struct SListNode 
  12. {
  13. 	SLTDataType data;
  14. 	struct SListNode* next;
  15. }SLTNode;
  16.  
  17. void SLTPrint(SLTNode* phead);
  18.  
  19. //尾插
  20. void SLTPushBack(SLTNode** pphead, SLTDataType x);
  21. //头插
  22. void SLTPushFront(SLTNode** pphead, SLTDataType x);
  23. //尾删
  24. void SLTPopBack(SLTNode** pphead);
  25. //头删
  26. void SLTPopFront(SLTNode** pphead);
  27.  
  28. //查找
  29. SLTNode* SLTFind(SLTNode* phead, SLTDataType x);
  30. //在指定位置之前插⼊数据
  31. void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
  32. //删除pos节点
  33. void SLTErase(SLTNode** pphead, SLTNode* pos);
  34. //在指定位置之后插⼊数据
  35. void SLTInsertAfter(SLTNode* pos, SLTDataType x);
  36. //删除pos之后的节点
  37. void SLTEraseAfter(SLTNode* pos);
  38. //销毁链表
  39. void SListDesTroy(SLTNode** pphead);
  1. //SList.c
  2.  
  3. #include"SList.h"
  4.  
  5. void SLTPrint(SLTNode* phead)
  6. {
  7. 	SLTNode* pcur = phead;
  8. 	while (pcur)//pcur != NULL
  9. 	{
  10. 		printf("%d->", pcur->data);
  11. 		pcur = pcur->next;
  12. 	}
  13. 	printf("NULL\n");
  14. }
  15.  
  16. SLTNode* SLTBuyNode(SLTDataType x)
  17. {
  18. 	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
  19. 	if (newnode == NULL)
  20. 	{
  21. 		perror("malloc fail!");
  22. 		exit(1);
  23. 	}
  24. 	newnode->data = x;
  25. 	newnode->next = NULL;
  26.  
  27. 	return newnode;
  28. }
  29.  
  30. //尾插
  31. void SLTPushBack(SLTNode** pphead, SLTDataType x)
  32. {
  33. 	assert(pphead);
  34. 	//*pphead 就是指向第一个节点的指针
  35. 	//空链表和非空链表
  36. 	SLTNode* newnode = SLTBuyNode(x);
  37. 	if (*pphead == NULL)
  38. 	{
  39. 		*pphead = newnode;
  40. 	}
  41. 	else 
  42. 	{
  43. 		//找尾
  44. 		SLTNode* ptail = *pphead;
  45. 		while (ptail->next)
  46. 		{
  47. 			ptail = ptail->next;
  48. 		}
  49. 		//ptail指向的就是尾结点
  50. 		ptail->next = newnode;
  51. 	}
  52. }
  53.  
  54. //头插
  55. void SLTPushFront(SLTNode** pphead, SLTDataType x)
  56. {
  57. 	assert(pphead);
  58. 	SLTNode* newnode = SLTBuyNode(x);
  59. 	//newnode *pphead
  60. 	newnode->next = *pphead;
  61. 	*pphead = newnode;
  62. }
  63.  
  64. //尾删
  65. void SLTPopBack(SLTNode** pphead)
  66. {
  67. 	//链表不能为空
  68. 	assert(pphead && *pphead);
  69. 	//链表只有一个节点
  70. 	if ((*pphead)->next == NULL) //-> 优先级高于*
  71. 	{
  72. 		free(*pphead);
  73. 		*pphead = NULL;
  74. 	}
  75. 	else {
  76. 		//链表有多个节点
  77.  
  78. 		SLTNode* prev = *pphead;
  79. 		SLTNode* ptail = *pphead;
  80. 		while (ptail->next)
  81. 		{
  82. 			prev = ptail;
  83. 			ptail = ptail->next;
  84. 		}
  85. 		//prev ptail
  86. 		free(ptail);
  87. 		ptail = NULL;
  88. 		prev->next = NULL;
  89. 	}
  90. }
  91.  
  92. //头删
  93. void SLTPopFront(SLTNode** pphead)
  94. {
  95. 	//链表不能为空
  96. 	assert(pphead && *pphead);
  97.  
  98. 	SLTNode* next = (*pphead)->next; //-> 优先级高于*
  99. 	free(*pphead);
  100. 	*pphead = next;
  101. }
  102.  
  103. //查找
  104. SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
  105. {
  106. 	SLTNode* pcur = phead;
  107. 	while (pcur)//等价于pcur != NULL
  108. 	{
  109. 		if (pcur->data == x)
  110. 		{
  111. 			return pcur;
  112. 		}
  113. 		pcur = pcur->next;
  114. 	}
  115. 	//pcur == NULL
  116. 	return NULL;
  117. }
  118.  
  119. //在指定位置之前插入数据
  120. void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
  121. {
  122. 	assert(pphead && *pphead);
  123. 	assert(pos);
  124. 	SLTNode* newnode = SLTBuyNode(x);
  125. 	//若pos == *pphead;说明是头插
  126. 	if (pos == *pphead)
  127. 	{
  128. 		SLTPushFront(pphead, x);
  129. 	}
  130. 	else {
  131. 		SLTNode* prev = *pphead;
  132. 		while (prev->next != pos)
  133. 		{
  134. 			prev = prev->next;
  135. 		}
  136. 		//prev -> newnode -> pos
  137. 		newnode->next = pos;
  138. 		prev->next = newnode;
  139. 	}
  140. }
  141.  
  142. //在指定位置之后插入数据
  143. void SLTInsertAfter(SLTNode* pos, SLTDataType x)
  144. {
  145. 	assert(pos);
  146.  
  147. 	SLTNode* newnode = SLTBuyNode(x);
  148. 	//pos -> newnode -> pos->next
  149. 	newnode->next = pos->next;
  150. 	pos->next = newnode;
  151. }
  152.  
  153. //删除pos节点
  154. void SLTErase(SLTNode** pphead, SLTNode* pos)
  155. {
  156. 	assert(pphead && *pphead);
  157. 	assert(pos);
  158. 	//pos是头结点/pos不是头结点
  159. 	if (pos == *pphead)
  160. 	{
  161. 		//头删
  162. 		SLTPopFront(pphead);
  163. 	}
  164. 	else {
  165. 		SLTNode* prev = *pphead;
  166. 		while (prev->next != pos)
  167. 		{
  168. 			prev = prev->next;
  169. 		}
  170. 		//prev pos pos->next
  171. 		prev->next = pos->next;
  172. 		free(pos);
  173. 		pos = NULL;
  174. 	}
  175. }
  176.  
  177. //删除pos之后的节点
  178. void SLTEraseAfter(SLTNode* pos)
  179. {
  180. 	assert(pos && pos->next);
  181. 	SLTNode* del = pos->next;
  182. 	//pos del del->next
  183. 	pos->next = del->next;
  184. 	free(del);
  185. 	del = NULL;
  186. }
  187.  
  188. //销毁链表
  189. void SListDesTroy(SLTNode** pphead)
  190. {
  191. 	assert(pphead && *pphead);
  192.  
  193. 	SLTNode* pcur = *pphead;
  194. 	while (pcur)
  195. 	{
  196. 		SLTNode* next = pcur->next;
  197. 		free(pcur);
  198. 		pcur = next;
  199. 	}
  200. 	//pcur
  201. 	*pphead = NULL;
  202. }

在接下来我们将会学习利用单向链表实现通讯录等有意思的东西，如果本篇有不理解的地方，欢迎私信我或在评论区指出，期待与你们共同进步。创作不易，望各位大佬一键三连！

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/723590
推荐阅读
相关标签

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

  

闽ICP备14008679号