• 【单链表】无头单项不循环（2）

    目录

    Test.c主函数

    test5

    test6

    test7

    test8

    test9

    Test.c总代码

    SList.h头文件&函数声明

    头文件

    函数声明

    SList.h总代码

    SList.c函数实现

    查询SLFind 

    pos前面插入  

    pos后面插入

    pos后面删除

    pos删除

    空间释放

    SList.c总代码

    今天链表。 

    Test.c主函数

    #include"SList.h"
    1. int main()
    2. {
    3. 	SLNode* phead = NULL;//结构体指针变量存放结构体的地址 头节点
    4. 	test5(&phead);//测试查找
    5. 	test6(&phead);//测试在pos前面插入
    6. 	test7(&phead);//测试在pos后面插入
    7. 	test8(&phead);//测试删除pos后面的元素
    8. 	test9(&phead);//测试删除pos的元素
    9. 	return 0;
    10. }

    test5

    1. void test5(SLNode** pphead)//测试查找
    2. {
    3. 	SLNode*ret=SLFind(*pphead, 77);
    4. 	if (ret != NULL)
    5. 	{
    6. 		printf("找到了：%d\n", ret->val);
    7. 	}
    8. 	else
    9. 	{
    10. 		printf("没找到\n");
    11. 	}
    12. }

    test6

    1. void test6(SLNode** pphead)//测试在pos前面位置插入的元素
    2. {
    3. 	SLNode* ret = SLFind(*pphead, 77);
    4. 	SLInsert(pphead, ret, 34);
    5. 	SLNode* pos = SLFind(*pphead, 34);
    6. 	SLInsert(pphead, pos,  78);
    7. 	SLPrint(*pphead);
    8. }

    test7

    1. void test7(SLNode** pphead)//测试在pos后面位置插入的元素
    2. {
    3. 	SLNode* ret = SLFind(*pphead, 77);
    4. 	SLInsertAfter(pphead, ret, 99);
    5. 	SLPrint(*pphead);
    6. }

    test8

    1. void test8(SLNode** pphead)//测试删除pos后面的元素
    2. {
    3. 	SLNode* ret = SLFind(*pphead, 77);
    4. 	SLEraseAfter(pphead, ret);//99
    5. 	SLPrint(*pphead);
    6. }

    test9

    1. void test9(SLNode** pphead)//测试删除pos的元素
    2. {
    3. 	SLNode* ret = SLFind(*pphead, 78);
    4. 	SLErase(pphead, ret);
    5. 	SLPrint(*pphead);
    6. }

    Test.c总代码

    1. #include"SList.h"
    2. void test1(SLNode** pphead)//测试尾插
    3. {
    4. 	SLPushBack(pphead, 10);
    5. 	SLPushBack(pphead, 20);
    6. 	SLPushBack(pphead, 30);
    7. 	SLPushBack(pphead, 40);
    8. 	SLPrint(*pphead);
    9. }
    10.  
    11. void test2(SLNode** pphead)//测试头插
    12. {
    13. 	SLPushFront(pphead, 77);
    14. 	SLPushFront(pphead, 66);
    15. 	SLPushFront(pphead, 55);
    16. 	SLPushFront(pphead, 33);
    17. 	SLPrint(*pphead);
    18. }
    19.  
    20. //
    21.  
    22. void test3(SLNode** pphead)//测试头删
    23. {
    24. 	SLPopFront(pphead);
    25. 	SLPopFront(pphead);
    26. 	SLPopFront(pphead);
    27. 	SLPrint(*pphead);
    28. }
    29.  
    30. void test4(SLNode** pphead)//测试尾删
    31. {
    32. 	SLPopBack(pphead);
    33. 	SLPopBack(pphead);
    34. 	SLPrint(*pphead);
    35. }
    36.  
    37. void test5(SLNode** pphead)//测试查找
    38. {
    39. 	SLNode*ret=SLFind(*pphead, 77);
    40. 	if (ret != NULL)
    41. 	{
    42. 		printf("找到了：%d\n", ret->val);
    43. 	}
    44. 	else
    45. 	{
    46. 		printf("没找到\n");
    47. 	}
    48. }
    49.  
    50. void test6(SLNode** pphead)//测试在pos前面位置插入的元素
    51. {
    52. 	SLNode* ret = SLFind(*pphead, 77);
    53. 	SLInsert(pphead, ret, 34);
    54. 	SLNode* pos = SLFind(*pphead, 34);
    55. 	SLInsert(pphead, pos,  78);
    56. 	SLPrint(*pphead);
    57. }
    58.  
    59.  
    60. void test7(SLNode** pphead)//测试在pos后面位置插入的元素
    61. {
    62. 	SLNode* ret = SLFind(*pphead, 77);
    63. 	SLInsertAfter(pphead, ret, 99);
    64. 	SLPrint(*pphead);
    65. }
    66.  
    67.  
    68. void test8(SLNode** pphead)//测试删除pos后面的元素
    69. {
    70. 	SLNode* ret = SLFind(*pphead, 77);
    71. 	SLEraseAfter(pphead, ret);//99
    72. 	SLPrint(*pphead);
    73. }
    74.  
    75. void test9(SLNode** pphead)//测试删除pos的元素
    76. {
    77. 	SLNode* ret = SLFind(*pphead, 78);
    78. 	SLErase(pphead, ret);
    79. 	SLPrint(*pphead);
    80. }
    81.  
    82. int main()
    83. {
    84. 	SLNode* phead = NULL;//结构体指针变量存放结构体的地址 头节点
    85. 	test1(&phead);//测试尾插
    86. 	test2(&phead);//测试头插
    87. 	test3(&phead);//测试尾删
    88.     test4(&phead);//测试头删
    89. 	test5(&phead);//测试查找
    90. 	test6(&phead);//测试在pos前面插入
    91. 	test7(&phead);//测试在pos后面插入
    92. 	test8(&phead);//测试删除pos后面的元素
    93. 	test9(&phead);//测试删除pos的元素
    94. 	return 0;
    95. }

    SList.h头文件&函数声明

    头文件

    1. #pragma once
    2. #include
    3. #include
    4. #include

    函数声明

    • 单链表元素查询 
    1. //找到某个数值在单链表
    2. SLNode* SLFind(SLNode* phead, SLNDataType x);
    •  在pos前面位置插入元素
    1. //在pos的前面插入
    2. void SLInsert(SLNode** pphead, SLNode*pos,SLNDataType x);
    • 在pos后面插入元素 
    1. //在pos的后面插入
    2. void SLInsertAfter(SLNode** pphead, SLNode* pos, SLNDataType x);
    •  删除pos后面的位置的元素
    1. //删除pos的后面位置
    2. void SLEraseAfter(SLNode** pphead, SLNode* pos);
    • 删除pos位置的元素 
    1. //删除pos位置
    2. void SLErase(SLNode** pphead, SLNode* pos);
    •  空间释放
    1. //空间释放
    2. void SLDestroy(SLNode** pphead);

    SList.h总代码

    1. #pragma once
    2. #include
    3. #include
    4. #include
    5.  
    6. //创建单链表
    7. typedef int SLNDataType;//单链表节点数据类型
    8.  
    9. typedef struct SListNode//创建节点
    10. {
    11. 	SLNDataType val;
    12. 	struct SListNode* next;
    13. }SLNode;
    14.  
    15. //打印数据
    16. void SLPrint(SLNode* phead);
    17.  
    18. //尾插
    19. void SLPushBack(SLNode** pphead, SLNDataType x);
    20.  
    21. //头插
    22. void SLPushFront(SLNode** pphead, SLNDataType x);
    23.  
    24. //头删
    25. void SLPopFront(SLNode** pphead);
    26.  
    27. //尾删
    28. void SLPopBack(SLNode** pphead);
    29.  
    30. //找到某个数值在单链表
    31. SLNode* SLFind(SLNode* phead, SLNDataType x);
    32.  
    33. //在pos的前面插入
    34. void SLInsert(SLNode** pphead, SLNode*pos,SLNDataType x);
    35.  
    36. //在pos的后面插入
    37. void SLInsertAfter(SLNode** pphead, SLNode* pos, SLNDataType x);
    38.  
    39. //删除pos的后面位置
    40. void SLEraseAfter(SLNode** pphead, SLNode* pos);
    41.  
    42. //删除pos位置
    43. void SLErase(SLNode** pphead, SLNode* pos);
    44.  
    45. //空间释放
    46. void SLDestroy(SLNode** pphead);

    SList.c函数实现

    查询SLFind 

    1. //在单链表中查找某个数字
    2. //找到了返回这个链表的地址
    3. //没找到返回NULL
    4. SLNode* SLFind(SLNode* phead, SLNDataType x)
    5. {
    6. 	SLNode* cur = phead;
    7. 	while(cur)
    8. 	{
    9. 		if (cur->val == x)
    10. 		{
    11. 			return cur;
    12. 		}
    13. 		cur = cur->next;
    14. 	}
    15. 	return NULL;
    16. }

    pos前面插入  

    1. //在pos的前面插入
    2. void SLInsert(SLNode** pphead, SLNode*pos,SLNDataType x)
    3. {
    4. 	//严格限定单链表里面必须有一个有效节点
    5. 	assert(pphead);//应该没有人喝醉酒了吧
    6. 	assert(*pphead);
    7. 	assert(pos);
    8. 	SLNode* newnode = CreateNode(x);
    9. 	SLNode* cur = *pphead;
    10. 	SLNode* prve = NULL;
    11. 	//适合中间和尾
    12. 	if (prve)
    13. 	{
    14. 		while (cur != pos)
    15. 		{
    16. 			prve = cur;
    17. 			cur = cur->next;
    18. 		}
    19. 		prve->next = newnode;
    20. 		newnode->next = cur;
    21. 	}
    22. 	else
    23. 	{
    24. 		//头插
    25. 		SLPushFront(pphead, x);
    26. 	}
    27. }

    pos后面插入

    1. //在pos的后面插入
    2. void SLInsertAfter(SLNode** pphead, SLNode* pos, SLNDataType x)
    3. {
    4. 	//严格限定单链表里面必须有一个有效节点
    5. 	assert(pphead);//应该没有人喝醉酒了吧
    6. 	assert(*pphead);
    7. 	assert(pos);
    8. 	SLNode* newnode = CreateNode(x);
    9. 	newnode->next = pos->next;
    10. 	pos->next = newnode;
    11. 	//头和尾都不用处理。
    12. }

    pos后面删除

    1. //删除pos的后面位置
    2. void SLEraseAfter(SLNode** pphead, SLNode* pos)
    3. {
    4. 	//pos在最后一个不可
    5. 	assert(pos->next);
    6. 	assert(pos);
    7. 	SLNode* tmp = pos->next;
    8. 	pos->next = pos->next->next;
    9. 	free(tmp);
    10. 	tmp = NULL;
    11. }

    pos删除

    1. //删除pos位置
    2. void SLErase(SLNode** pphead, SLNode* pos)
    3. {
    4. 	assert(pos);
    5. 	SLNode* cur = *pphead;
    6. 	SLNode* prve = NULL;
    7. 	if (prve)
    8. 	{
    9. 		while (cur != pos)
    10. 		{
    11. 			prve = cur;
    12. 			cur = cur->next;
    13. 		}
    14. 		prve->next = cur->next;
    15. 		free(pos);
    16. 		pos = NULL;
    17. 	}
    18. 	else
    19. 	{
    20. 		*pphead = pos->next;
    21. 		free(pos);
    22. 		pos = NULL;
    23. 	}
    24. }

     

    空间释放

    1. //空间释放
    2. void SLDestroy(SLNode** pphead)
    3. {
    4. 	assert(*pphead);
    5. 	SLNode* cur = *pphead;
    6. 	while (cur)
    7. 	{
    8. 		SLNode* tmp = cur->next;
    9. 		free(cur);
    10. 		cur = tmp;//cur=cur->next
    11. 	}
    12. }

    SList.c总代码

    1. #include"SList.h"
    2. void SLPrint(SLNode* phead)
    3. {
    4. 	assert(phead);
    5. 	SLNode* tail = phead;
    6. 	printf("phead->");
    7. 	while (tail->next != NULL)
    8. 	{
    9. 		printf("%d->", tail->val);
    10. 		tail = tail->next;
    11. 	}
    12. 	printf("NULL");
    13. 	printf("\n");
    14. }
    15.  
    16.  
    17. //创建链表的节点---结构体
    18. SLNode* CreateNode(SLNDataType x)
    19. {
    20. 	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
    21. 	if (newnode == NULL)
    22. 	{
    23. 		perror("malloc");
    24. 		return;
    25. 	}
    26. 	newnode->val = x;
    27. 	newnode->next = NULL;
    28. 	return newnode;
    29. }
    30.  
    31. //测试尾插
    32. void SLPushBack(SLNode** pphead, SLNDataType x)
    33. {
    34. 	//assert(*pphead);
    35. 	SLNode* newnode = CreateNode(x);
    36. 	//无节点
    37. 	if (*pphead == NULL)
    38. 	{
    39. 		*pphead = newnode;
    40. 	}
    41. 	//多个节点
    42. 	else
    43. 	{
    44. 		SLNode* tail = *pphead;
    45. 		while (tail->next != NULL)
    46. 		{
    47. 			tail = tail->next;
    48. 		}
    49. 		tail->next = newnode;
    50. 	}
    51.  
    52. }
    53.  
    54.  
    55. //头插
    56. void SLPushFront(SLNode** pphead, SLNDataType x)
    57. {
    58. 	//assert(*pphead);
    59. 	SLNode* newnode = CreateNode(x);
    60.     newnode->next = *pphead;
    61.     *pphead = newnode;
    62. }
    63.  
    64.  
    65. //---删除就涉及空间的释放---断言（删过头）
    66. //头删
    67. void SLPopFront(SLNode** pphead)
    68. {
    69. 	assert(*pphead);
    70. 	SLNode* tail = *pphead;
    71. 	*pphead = (*pphead)->next;
    72. 	free(tail);
    73. 	tail = NULL;
    74. }
    75.  
    76.  
    77. //尾删
    78. void SLPopBack(SLNode** pphead)
    79. {
    80. 	assert(*pphead);
    81. 	//一个节点
    82. 	if ((*pphead)->next == NULL)
    83. 	{
    84. 		free(*pphead);
    85. 		*pphead = NULL;
    86. 	}
    87. 	else
    88. 	{
    89. 		SLNode* tail = *pphead;
    90. 		SLNode* prve = NULL;//虽然这里prve置为NULL和tail都是一样，但是在OJ题目当中会出错
    91. 		while (tail->next != NULL)
    92. 		{
    93. 			prve = tail;
    94. 			tail = tail->next;
    95. 		}
    96. 		prve->next = NULL;
    97. 		free(tail);
    98. 		tail = NULL;
    99. 	}
    100. }
    101.  
    102.  
    103.  
    104. //在单链表中查找某个数字
    105. //找到了返回这个链表的地址
    106. //没找到返回NULL
    107. SLNode* SLFind(SLNode* phead, SLNDataType x)
    108. {
    109. 	SLNode* cur = phead;
    110. 	while(cur)
    111. 	{
    112. 		if (cur->val == x)
    113. 		{
    114. 			return cur;
    115. 		}
    116. 		cur = cur->next;
    117. 	}
    118. 	return NULL;
    119. }
    120.  
    121.  
    122.  
    123.  
    124. //在pos的前面插入
    125. void SLInsert(SLNode** pphead, SLNode*pos,SLNDataType x)
    126. {
    127. 	//严格限定单链表里面必须有一个有效节点
    128. 	assert(pphead);//应该没有人喝醉酒了吧
    129. 	assert(*pphead);
    130. 	assert(pos);
    131. 	SLNode* newnode = CreateNode(x);
    132. 	SLNode* cur = *pphead;
    133. 	SLNode* prve = NULL;
    134. 	//适合中间和尾
    135. 	if (prve)
    136. 	{
    137. 		while (cur != pos)
    138. 		{
    139. 			prve = cur;
    140. 			cur = cur->next;
    141. 		}
    142. 		prve->next = newnode;
    143. 		newnode->next = cur;
    144. 	}
    145. 	else
    146. 	{
    147. 		//头插
    148. 		SLPushFront(pphead, x);
    149. 	}
    150. }
    151.  
    152.  
    153.  
    154. //在pos的后面插入
    155. void SLInsertAfter(SLNode** pphead, SLNode* pos, SLNDataType x)
    156. {
    157. 	//严格限定单链表里面必须有一个有效节点
    158. 	assert(pphead);//应该没有人喝醉酒了吧
    159. 	assert(*pphead);
    160. 	assert(pos);
    161. 	SLNode* newnode = CreateNode(x);
    162. 	newnode->next = pos->next;
    163. 	pos->next = newnode;
    164. 	//头和尾都不用处理。
    165. }
    166.  
    167.  
    168.  
    169. //删除pos的后面位置
    170. void SLEraseAfter(SLNode** pphead, SLNode* pos)
    171. {
    172. 	//pos在最后一个不可
    173. 	assert(pos->next);
    174. 	assert(pos);
    175. 	SLNode* tmp = pos->next;
    176. 	pos->next = pos->next->next;
    177. 	free(tmp);
    178. 	tmp = NULL;
    179. }
    180.  
    181.  
    182. //删除pos位置
    183. void SLErase(SLNode** pphead, SLNode* pos)
    184. {
    185. 	assert(pos);
    186. 	SLNode* cur = *pphead;
    187. 	SLNode* prve = NULL;
    188. 	if (prve)
    189. 	{
    190. 		while (cur != pos)
    191. 		{
    192. 			prve = cur;
    193. 			cur = cur->next;
    194. 		}
    195. 		prve->next = cur->next;
    196. 		free(pos);
    197. 		pos = NULL;
    198. 	}
    199. 	else
    200. 	{
    201. 		*pphead = pos->next;
    202. 		free(pos);
    203. 		pos = NULL;
    204. 	}
    205. }
    206.  
    207.  
    208.  
    209. //空间释放
    210. void SLDestroy(SLNode** pphead)
    211. {
    212. 	assert(*pphead);
    213. 	SLNode* cur = *pphead;
    214. 	while (cur)
    215. 	{
    216. 		SLNode* tmp = cur->next;
    217. 		free(cur);
    218. 		cur = tmp;//cur=cur->next
    219. 	}
    220. }

     

    最近改bug改的想砸电脑，保持冷静。下篇博客我们将继续链表其他类型。好好学习，天天向上。

    代码---------→【唐棣棣 (TSQXG) - Gitee.com】

    联系---------→【邮箱：2784139418@qq.com】

  • 相关阅读:
    恩智浦半导体基于离子阱研发“经典+量子”解决方案
    django 内置 JSON 字段 使用场景
    【python基础】文件和异常详解:使用、读取、写入、追加、保存用户的信息，以及优雅的处理异常
    Java类加载过程
    可视化3个10分类
    Maven 使用教程（二）
    利用 Kubernetes 降本增效？EasyMR 基于 Kubernetes 部署的探索实践
    odoo 云部署
    Pyqt常用代码片段
    K8s 之 节点亲和性的调度策略（NodeAffinity）
  • 原文地址：https://blog.csdn.net/m0_74841364/article/details/134253831