• 单链表（Single Link Table)——单文件实现

    一、单链表前言

    上篇文章我们讲述了顺序表，认真学习我们会发现顺序表优缺点。

    缺点1：头部和中部的插入删除效率都不行，时间和空间复杂度都为O(N);

    缺点2：空间不够了扩容有一定的消耗(尤其是realloc的异地扩容)；

    缺点3：扩容逻辑，可能还存在空间，就像我只需要插入170个数据，但是要扩容200个数据大小，就会造成浪费。

    优点1：尾插尾删足够快；

    优点2：下标的随机访问和修改很快很方便；

    基于顺序表的缺点我们通过今天的单链表来解决；

    二、链表

    2.1链表的基本概念和结构

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

    结构图：

    链表和顺序表一样也是通过结构体实现的，不一样的是链表中的结构体只含有有效数据和指向下个结构体的结构体指针

    让我们先通过代码实现一个简单的链表吧！

    1. #include<stdio.h>
    2. #include<stdlib.h> 
    3. typedef struct SListNode{
    4. 	int data;
    5. 	struct SListNode* next;
    6. }SLTNode;
    7. int main()
    8. {
    9. 	SLTNode*n1=(SLTNode*)malloc(sizeof(SLTNode));
    10. 	n1->data=1;
    11. 	SLTNode*n2=(SLTNode*)malloc(sizeof(SLTNode));
    12. 	n2->data=2;
    13. 	SLTNode*n3=(SLTNode*)malloc(sizeof(SLTNode));
    14. 	n3->data=3;
    15. 	n1->next=n2;
    16. 	n2->next=n3;
    17. 	n3->next=NULL;
    18. 	SLTNode*plist=n1;
    19. 	while(plist)
    20. 	{
    21. 		printf("%d->",plist->data);
    22. 		plist=plist->next;
    23. 	}
    24. 	printf("NULL\n");
    25. 	 return 0;
    26.  }

    这里我们开辟了三个结构体的空间用三个结构体指针指向每个结构体，然后将每个结构体里的结构体指针指向下一个结构体，再将每个结构体存入有效数据，一个简单的3长度的链表。

    注意：

    1.看上面的图逻辑上我们可能会认为是连续的，但是在物理地址内存上可能是连续的也可能是不连续的；

    2.现实中的每个结点都是从堆上开辟的

    3.从堆上开辟空间是按照一定策略的，两次连续的开辟空间可能是连续的，也可能是不连续的

    2.2链表的分类

    2.2.1单向或者双向

    2.2.2带头或者不带头

    2.2.3循环或者非循环

    虽然有这么多的链表结构，但是我们实际中最常用的还是两种结构

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

    三、无头单向非循环链表增删查改链表的实现

    3.1链表的创建

    1. typedef int SLTDatatype;
    2. typedef struct SListNode
    3. {
    4. 	SLTDatatype data;
    5. 	struct SListNode* next;
    6. }SLTNode;

    3.2填充数据及开辟新的结点

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

    链表的实现靠的是结构体里的结构体指针指向下一个结构体链接，所以我们要将新的结点返回，

    返回的是结构体指针，定义函数是也要结构体指针接受。

    3.3打印链表

    1. void SLprint(SLTNode* phead)
    2. {
    3. 	SLTNode* cur = phead;
    4. 	while (cur != NULL)
    5. 	{
    6. 		printf("%d->", cur->data);
    7. 		cur = cur->next;
    8. 	}
    9. 	printf("NULL\n");
    10. }

    我们是靠头结构体指针找到链表的，但是打印有效数据要移动指针所以我们就要在一开始创建一个指针，利用这个指针的移动打印数据，当这个指针为空时并不是指向空时停止打印。

    3.4查找有效数据

    1. SLTNode* SLFind(SLTNode* phead, SLTDatatype x)
    2. {
    3. 	SLTNode* cur = phead;
    4. 	while (cur)
    5. 	{
    6. 		if (cur->data = x)
    7. 		{
    8. 			return cur;
    9. 		}
    10. 		cur = cur->next;
    11. 	}
    12. 	return NULL;
    13. }

    和打印有效数据相似通过另一个指针的移动查找我们需要的有效数据，当指针为空时我们找不到有效数据返回NULL，当找到有效数据时返回指向含有这个有效数据的结构体；

    3.5单链表尾插

    1. void SLTPushBack(SLTNode** pphead, SLTDatatype x)
    2. {
    3. 	SLTNode* newnode = BuySLT(x);
    4. 	if (*pphead == NULL)
    5. 	{
    6. 		*pphead = newnode;
    7. 	}
    8. 	else
    9. 	{
    10. 		SLTNode* tail = *pphead;
    11. 		while (tail->next)
    12. 		{
    13. 			tail = tail->next;
    14. 		}
    15. 		tail->next = newnode;
    16. 	}
    17. }

    首先我们需要一个空结构体指针指向开辟好的返回值为结构体指针，当无链表时也相当于头插我们只需将开辟好返回值为结构体指针赋值给空指针就行，此时这个链表只有一个结构体；当链表已经形成时此时才是我们的尾插，我们需要另一个指针从头开始找到链表末尾的空指针，再将这个空指针指向以开辟好的返回值为结构体指针就可以从尾部将其串联起来；

    为什么要使用二级指针呢？

    我们是有一个指针指向空或者链表的头，在尾插时我们要通过头指针的移动增添数据，但是这个指针我们不可以移动，移动的话会造成内存泄漏，所以我们又创建一个指针将这个指针指向我们的空或者链表的头，通过指针的操作将我们的链表串联起来，我们也可以将这个指针想象成我们的头指针，这个指针会变化相当于头指针变化，但是我们是在一个函数域中操作，除了这个作用域一切都会销毁，相当于什么都没敢。通俗的说我们是在操作头指针，在另个作用域中改变我们原有的值只能通过二级指针实现，但是头指针已经是个指针了，所以我们需要一个二级指针。

    3.6尾删

    1. void SLTPopBack(SLTNode** pphead)
    2. {
    3. 	if ((*pphead)->next == NULL)
    4. 	{
    5. 		free(*pphead);
    6. 		*pphead = NULL;
    7. 	}
    8. 	else
    9. 	{
    10.         SLTNode* tail = *pphead;
    11. 		while (tail->next->next)
    12. 		{
    13. 			tail = tail->next;
    14. 		}
    15. 		free(tail->next);
    16. 		tail->next = NULL;
    17. 	}
    18. }

    首先我们要判断这个链表是否只有一个结构体，如果只有一个结构体直接将这个结构体释放销毁就行了；如果有多个结构体链接只需要找到倒数第二个结构体中的指向最后一个结构体的指针，释放这个指向最后一个结构体的指针就是可以实现尾删；

    3.7头插

    1. void SLPushFront(SLTNode** pphead, SLTDatatype x)
    2. {
    3. 	SLTNode* newnode = BuySLT(x);
    4. 	if ((*pphead) == NULL)
    5. 	{
    6. 		*pphead = newnode;
    7. 	}
    8. 	else
    9. 	{
    10. 		SLTNode* newnode = BuySLT(x);
    11. 		newnode->next = *pphead;
    12. 		*pphead = newnode;
    13. 	}
    14. }

    如果这个头指针为空时及没有链表，直接将这个指针指向开辟好的结构体的就行，如果不为空，将开辟好的结构体里指向下一个结构体的结构体指针指向我们的头指针，再将头指针指向开辟好的结构体就行；

    3.8头删

    1. void SLPopFront(SLTNode** pphead)
    2. {
    3. 	if ((*pphead) == NULL)
    4. 	{
    5. 		free(*pphead);
    6. 		*pphead = NULL;
    7. 	}
    8. 	else
    9. 	{
    10. 		SLTNode* newhead = (*pphead)->next;
    11. 		free(*pphead);
    12. 		*pphead = newhead;
    13. 	}
    14. }

    首先我们还是先判断这个链表是否只含有一个结构体，如果只含有一个结构体和尾删的方法一样

    如果含有多个结构体头删，我们只需要新创建一个指针保存第一个结构体里储存着第二个结构体的指针，然后释放掉我们的头指针，再将新创建的指针赋值给头指针就可以完成尾删。

    到这里无头单向非循环链表增删查改的重点内容和注意事项就讲解完毕了，下面我们实现一下链表中间随机的增删查改，就不一一讲解了，大家自行了解；

    四、无头单向非循环链表中间随机增删查改

    4.1在pos位置后插入x

    1. void SLInsertAfter(SLTNode* pos, SLTDatatype x)
    2. {
    3. 	SLTNode* newnode = BuySLT(x);
    4. 	newnode->next = pos->next;
    5. 	pos->next = newnode;
    6. }

    4.2在pos位置后插入x

    1. void SLInsert(SLTNode** pphead, SLTNode* pos, SLTDatatype x)
    2. {
    3. 	if (pos == *pphead)
    4. 	{
    5. 		SLPushFront(pphead, x);
    6. 	}
    7. 	else
    8. 	{
    9. 		SLTNode* newnode = BuySLT(x);
    10. 		SLTNode* prev = *pphead;
    11. 		while (prev->next != pos)
    12. 		{
    13. 			prev = prev->next;
    14. 		}
    15. 		prev->next = newnode;
    16. 		newnode->next = pos;
    17.  
    18. 	}
    19. }

    4.3删除pos位置的值

    1. void SLTErase(SLTNode** pphead, SLTNode* pos)
    2. {
    3. 	if ((*pphead) == pos)
    4. 	{
    5. 		SLPopFront(pphead);
    6. 	}
    7. 	else
    8. 	{
    9. 		SLTNode* prev = *pphead;
    10. 		while (prev->next != pos)
    11. 		{
    12. 			prev = prev->next;
    13. 		}
    14. 		prev->next = pos->next;
    15. 		free(pos);
    16. 		pos = NULL;
    17. 	}
    18. }

     4.4删除pos位置后面的值

    1. void SLEraseAfter(SLTNode* pos)
    2. {
    3. 	assert(pos->next);
    4. 	SLTNode* newnode = pos->next->next;
    5. 	free(pos->next);
    6. 	pos->next = newnode;
    7. }

    五、无头单向非循环链表增删查改完整代码

    1. #define _CRT_SECURE_NO_WARNINGS 67
    2. #include<stdio.h>
    3. #include<assert.h>
    4. #include<stdlib.h>
    5. typedef int SLTDatatype;
    6. typedef struct SListNode
    7. {
    8. 	SLTDatatype data;
    9. 	struct SListNode* next;
    10. }SLTNode;
    11. //打印 
    12. void SLprint(SLTNode* phead)
    13. {
    14. 	SLTNode* cur = phead;
    15. 	while (cur != NULL)
    16. 	{
    17. 		printf("%d->", cur->data);
    18. 		cur = cur->next;
    19. 	}
    20. 	printf("NULL\n");
    21. }
    22. //开辟新的空间
    23. SLTNode* BuySLT(SLTDatatype x)
    24. {
    25. 	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
    26. 	if (newnode == NULL)
    27. 	{
    28. 		perror("malloc failed");
    29. 		exit(-1);
    30. 	}
    31. 	newnode->data = x;
    32. 	newnode->next = NULL;
    33. 	return newnode;
    34. }
    35. //查找
    36. SLTNode* SLFind(SLTNode* phead, SLTDatatype x)
    37. {
    38. 	SLTNode* cur = phead;
    39. 	while (cur)
    40. 	{
    41. 		if (cur->data = x)
    42. 		{
    43. 			return cur;
    44. 		}
    45. 		cur = cur->next;
    46. 	}
    47. 	return NULL;
    48. }
    49. //尾插
    50. void SLTPushBack(SLTNode** pphead, SLTDatatype x)
    51. {
    52. 	SLTNode* newnode = BuySLT(x);
    53. 	if (*pphead == NULL)
    54. 	{
    55. 		*pphead = newnode;
    56. 	}
    57. 	else
    58. 	{
    59. 		SLTNode* tail = *pphead;
    60. 		while (tail->next)
    61. 		{
    62. 			tail = tail->next;
    63. 		}
    64. 		tail->next = newnode;
    65. 	}
    66. }
    67. //尾删
    68. void SLTPopBack(SLTNode** pphead)
    69. {
    70. 	if ((*pphead)->next == NULL)
    71. 	{
    72. 		free(*pphead);
    73. 		*pphead = NULL;
    74. 	}
    75. 	else
    76. 	{
    77. 		SLTNode* tail = *pphead;
    78. 		while (tail->next->next)
    79. 		{
    80. 			tail = tail->next;
    81. 		}
    82. 		free(tail->next);
    83. 		tail->next = NULL;
    84. 	}
    85. }
    86. //头插	
    87. void SLPushFront(SLTNode** pphead, SLTDatatype x)
    88. {
    89. 	SLTNode* newnode = BuySLT(x);
    90. 	if ((*pphead) == NULL)
    91. 	{
    92. 		*pphead = newnode;
    93. 	}
    94. 	else
    95. 	{
    96. 		SLTNode* newnode = BuySLT(x);
    97. 		newnode->next = *pphead;
    98. 		*pphead = newnode;
    99. 	}
    100. }
    101. //头删 
    102. void SLPopFront(SLTNode** pphead)
    103. {
    104. 	if ((*pphead) == NULL)
    105. 	{
    106. 		free(*pphead);
    107. 		*pphead = NULL;
    108. 	}
    109. 	else
    110. 	{
    111. 		SLTNode* newhead = (*pphead)->next;
    112. 		free(*pphead);
    113. 		*pphead = newhead;
    114. 	}
    115. }
    116. //在pos位置后插入x
    117. void SLInsertAfter(SLTNode* pos, SLTDatatype x)
    118. {
    119. 	SLTNode* newnode = BuySLT(x);
    120. 	newnode->next = pos->next;
    121. 	pos->next = newnode;
    122. }
    123. //在pos位置前插入x 
    124. void SLInsert(SLTNode** pphead, SLTNode* pos, SLTDatatype x)
    125. {
    126. 	if (pos == *pphead)
    127. 	{
    128. 		SLPushFront(pphead, x);
    129. 	}
    130. 	else
    131. 	{
    132. 		SLTNode* newnode = BuySLT(x);
    133. 		SLTNode* prev = *pphead;
    134. 		while (prev->next != pos)
    135. 		{
    136. 			prev = prev->next;
    137. 		}
    138. 		prev->next = newnode;
    139. 		newnode->next = pos;
    140.  
    141. 	}
    142. }
    143. void SLTErase(SLTNode** pphead, SLTNode* pos)
    144. {
    145. 	if ((*pphead) == pos)
    146. 	{
    147. 		SLPopFront(pphead);
    148. 	}
    149. 	else
    150. 	{
    151. 		SLTNode* prev = *pphead;
    152. 		while (prev->next != pos)
    153. 		{
    154. 			prev = prev->next;
    155. 		}
    156. 		prev->next = pos->next;
    157. 		free(pos);
    158. 		pos = NULL;
    159. 	}
    160. }
    161.  
    162. void SLEraseAfter(SLTNode* pos)
    163. {
    164. 	assert(pos->next);
    165. 	SLTNode* newnode = pos->next->next;
    166. 	free(pos->next);
    167. 	pos->next = newnode;
    168. }
    169. int main()
    170. {
    171. 	SLTNode* plist = NULL;
    172. 	//尾插
    173. 	SLTPushBack(&plist, 1);
    174. 	SLTPushBack(&plist, 2);
    175. 	SLTPushBack(&plist, 3);
    176. 	SLTPushBack(&plist, 4);
    177. 	SLTPushBack(&plist, 5);
    178. 	SLTPushBack(&plist, 10);
    179. 	printf("尾插:\n");
    180. 	SLprint(plist);
    181. 	//尾删
    182. 	printf("尾删:\n");
    183. 	SLTPopBack(&plist);
    184. 	SLprint(plist);
    185. 	//头插
    186. 	printf("头插:\n");
    187. 	SLPushFront(&plist, 10);
    188. 	SLprint(plist);
    189. 	//头删
    190. 	printf("头删:\n");
    191. 	SLPopFront(&plist);
    192. 	SLprint(plist);
    193. 	//在pos位置后插入x
    194. 	SLTNode* pos1 = SLFind(plist, 1);
    195. 	SLInsertAfter(pos1, 10);
    196. 	printf("在pos位置后插入x\n");
    197. 	SLprint(plist);
    198. 	//在pos位置前插入x
    199. 	SLTNode* pos2 = SLFind(plist, 1);
    200. 	printf("在pos位置前插入x\n");
    201. 	SLInsert(&plist, pos2, 20);
    202. 	SLprint(plist);
    203. 	//删除pos位置的值
    204. 	SLTNode* pos3 = SLFind(plist, 10);
    205. 	SLTErase(&plist, pos3);
    206. 	printf("删除pos位置的值:\n");
    207. 	SLprint(plist);
    208. 	//删除pos后面的值
    209. 	SLTNode* pos4 = SLFind(plist, 1);
    210. 	SLEraseAfter(pos4);
    211. 	printf("删除pos位置后面的值:\n");
    212. 	SLprint(pos4);
    213. 	return 0;
    214. }

    到这里我们的无头单向非循环链表增删查改的所有内容就讲解完了，有什么问题或者需要指正的可以在评论区留下您宝贵的意见。

  • 相关阅读:
    单链表的基本操作
    ECCV 2022 | 石溪大学联合小鹏汽车提出先验知识指导的无监督领域自适应
    熵-条件熵-联合熵-互信息-交叉熵
    java毕业设计Sneaker’sHome设计网站mybatis+源码+调试部署+系统+数据库+lw
    C++ 学习（14）类和对象 - 多态、多态原理解析、纯虚函数和抽象类、虚析构与纯析构函数
    《舌尖上的中国》经典语录
    颜色扩散类dp及其优化：0919T2
    造一个float类型二维矩阵,并将二维矩阵存储到一个floa*中
    jquery--遍历
    重磅 | 思特威获得ISO 26262:2018汽车功能安全ASIL D流程认证证书
  • 原文地址：https://blog.csdn.net/qq_55119554/article/details/132817167