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

[数据结构]单链表(C语言版)_单链表c语言

作者：很楠不爱3 | 2024-05-12 02:08:09

赞

踩

单链表c语言

在学习单链表之前我们已经学习了顺序表相关的基本操作，顺序表访问元素更加方便，物理地址是连续的；但是也有一些缺点：

1.在头部插入或者从中间插入或删除元素时需要搬移数据，效率较低

2.在插入数据时可能存在空间不足的情况，需要扩容

因此就会出现另一种线性表---链表

1.链表的概念

链表顾名思义就是链式的存储结构，元素的逻辑顺序是由指针来依次连接的。

链表中有多个节点，每一个节点里储存着数据，还有指向下一个节点的指针 。

2.单链表的定义

我们要实现的是不带头结点的非循环单向链表

单链表的结构包括数值域和指针域

  1. typedef int DataType;
  2. typedef struct SListNode
  3. {
  4. 	DataType data;
  5. 	struct SListNode* next;//指向下一个节点
  6. }SListNode;

3.单链表节点的创建

  1. SListNode* BuySListNode(DataType x)
  2. {
  3. 	SListNode* newNode = (SListNode*)malloc(sizeof(SListNode));//这个动态内存空间是用来存放这个结构体类型的
  4. 	if (NULL == newNode)
  5. 	{
  6. 		printf("创建节点失败！！！！");
  7. 		exit(0);
  8. 	}
  9. 	newNode->data = x;
  10. 	newNode->next = NULL;
  11. 	return newNode;
  12. }

4.单链表的尾插

  1. void SListPushBack(SListNode** pplist,DataType x)
  2. {
  3. 	assert(*pplist);
  4. 	//如果pplist为空则需要让pplist指向刚刚插入的节点
  5. 	if (NULL == *pplist)
  6. 	{
  7. 		*pplist = BuySListNode(x);
  8. 	}
  9. 	else
  10. 	{
  11. 		//此时链表不为空
  12. 		//1.构建一个新节点
  13. 		SListNode* NewNode = BuySListNode(x);
  14. 		//2.找出原链表中的最后一个节点
  15. 		SListNode* cur = *pplist;
  16. 		while (cur->next)
  17. 		{
  18. 			//获取cur的下一个节点
  19. 			cur = cur->next;
  20. 		}
  21. 		//3.插入新节点
  22. 		cur->next = NewNode;
  23. 	}
  24. }

5.单链表的尾删

  1. //单链表的尾删
  2. void SListPopBack(SListNode** pplist)
  3. {
  4. 	assert(pplist);//保证pplist指向实参
  5. 	//1.空链表
  6. 	if (NULL == *pplist)
  7. 	{
  8. 		return;
  9. 	}
  10. 	else if (NULL == (*pplist)->next)
  11. 	{
  12. 		//2.链表中只有一个节点
  13. 		free(*pplist);
  14. 		*pplist = NULL;
  15. 	}
  16. 	else
  17. 	{
  18. 		//3.链表中有多个节点
  19. 		//a.找倒数第一个节点
  20. 		SListNode* cur = *pplist;
  21. 		SListNode* prev = NULL;//保存cur前一个节点
  22. 		while (cur->next)
  23. 		{
  24. 			prev = cur;
  25. 			cur = cur->next;
  26. 		}
  27. 		prev->next = NULL;
  28. 		free(cur);
  29. 		//b.找倒数第二个节点
  30. 		/*
  31. 		SListNode* cur = *pplist;
  32. 		while(cur->next->next)
  33. 		{
  34. 			cur = cur->next;
  35. 		}
  36. 		free(cur->next);
  37. 		cur->next = NULL;
  38. 		*/
  39. 		//c.错误写法
  40. 		/*while (cur->next)
  41. 		{
  42. 			cur = cur->next;
  43. 		}
  44. 		free(cur);*/
  45. 		
  46. 	}
  47. }

6.单链表打印

  1. //单链表打印
  2. void SListPrint(SListNode* plist)
  3. {
  4. 	SListNode* cur = plist;
  5. 	while (cur)
  6. 	{
  7. 		printf("&d--->", cur->data);
  8. 		cur = cur->next;
  9. 	}
  10. 	printf("NULL\n");//单链表最后一个节点指向空
  11. }

7.单链表头插

  1. // 单链表的头插
  2. //时间复杂度：O(1)
  3. void SListPushFront(SListNode** pplist, SLTDataType x)
  4. {
  5. 	//assert(pplist);
  6. 	//SListNode* newNode = BuySListNode(x);
  7. 	1.链表为空
  8. 	//if (NULL == *pplist)
  9. 	//{
  10. 	//	*pplist = newNode;
  11. 	//}
  12. 	//else
  13. 	//{
  14. 	//	//2.链表不空
  15. 	//	newNode->next = *pplist;
  16. 	//	*pplist = newNode;
  17. 	//}
  18. 	assert(pplist);
  19. 	//表面看上需要分情况讨论，但是在分析之后情况一可以与情况二合并
  20. 	SListNode* newNode = BuySListNode(x);
  21. 	newNode->next = *pplist;
  22. 	*pplist = newNode;
  23. }

8.单链表头删

  1. //单链表头删
  2. void SListPopFront(SListNode** pplist)
  3. {
  4. 	assert(pplist);
  5. 	//1.链表为空
  6. 	if (NULL == *pplist)
  7. 	{
  8. 		return;
  9. 	}
  10. 	//else if (NULL == (*pplist)->next)
  11. 	//{
  12. 	//	//2.链表只有一个节点
  13. 	//	free(*pplist);
  14. 	//	*pplist = NULL;
  15. 	//}
  16. 	else
  17. 	{
  18. 		//3.链表中有多个节点(分析后可知也包含一个节点的情况)
  19. 		SListNode* del = *pplist;//将要删除的节点保存起来
  20. 		*pplist = (*pplist)->next;
  21. 		free(del);
  22. 	}
  23.  
  24. }

9.单链表删除任意位置pos之后的值

  1. // 单链表删除pos位置之后的值
  2. //时间复杂度O(1)
  3. void SListEraseAfter(SListNode* pos)
  4. {
  5. 	SListNode* delNode = NULL;
  6. 	if (NULL == pos)
  7. 	{
  8. 		return;
  9. 	}
  10. 	delNode = pos->next;
  11. 	if (NULL == delNode)
  12. 	{
  13. 		return;
  14. 	}
  15. 	//pos->data = delNode->data;
  16. 	pos->next = delNode->next;
  17. 	free(delNode);
  18. }

代码中加一句pos->data = delNode->data就可以实现删除任意位置的值

但是不能删除最后一个节点位置的元素

10.单链表在任意位置pos之后插入

  1. //单链表在任意位置pos之后插入
  2. //时间复杂度：O(1)
  3. void SListInsertAfter(SListNode* pos, SLTDataType x)
  4. {
  5. 	SListNode* newNode = NULL;
  6. 	if (NULL == pos)
  7. 	{
  8. 		return;
  9. 	}
  10. 	newNode = BuySListNode(x);
  11. 	newNode->next = pos->next;//必须先让新节点接入到链表内然后将pos位置的节点指向新节点
  12. 	pos->next = newNode;
  13. }

新节点无法插入到pos之前，因为该方法未提供plist头节点

11.单链表在任意位置pos之前插入

  1. //单链表在任意位置pos之前插入
  2. void SListInsertBefore(SListNode** pplist, SListNode* pos, SLTDataType x)
  3. {
  4. 	assert(pplist);
  5. 	assert(pos);
  6. 	SListNode* newNode = NULL;
  7. 	if (pos == *pplist)
  8. 	{
  9. 		newNode = BuySListNode(x);
  10. 	}
  11. 	else
  12. 	{	
  13. 		SListNode* cur = *pplist;//将头节点保存起来，**pplist是plist的地址，*plist才是解引用后的指针
  14. 		while (cur->next != pos)
  15. 		{
  16. 			cur = cur->next;
  17. 		}
  18. 		newNode = BuySListNode(x);
  19. 		newNode->next = pos;
  20. 		cur->next = newNode;
  21. 	}
  22. }

11.单链表的销毁

  1. //单链表销毁
  2. void SListDestroy(SListNode** pplist)
  3. {
  4. 	assert(pplist);
  5. 	SListNode* cur = *pplist;
  6. 	while (cur)
  7. 	{
  8. 		*pplist = cur->next;
  9. 		free(cur);
  10. 		cur = *pplist;
  11. 	}
  12. 	*pplist = NULL;
  13. }

单链表的销毁很简单，只需要用cur把链表遍历一遍，每次让pplist头指针指向cur->next,释放cur所指向的当前节点，然后更新pplist指针的值，最后将pplist指向NULL。

12.单链表操作的测试

  1. void TestSList1()
  2. {
  3. 	SListNode* plist = NULL;//单链表的起始位置保存
  4.  
  5. 	//插入第一个节点时需要在此函数中通过形参来达到修改plist指向的修改
  6. 	SListPushBack(&plist, 1);//依次尾插1，2，3，4，5
  7. 	SListPrint(plist);
  8. 	SListPushBack(&plist, 2);
  9. 	SListPushBack(&plist, 3);
  10. 	SListPushBack(&plist, 4);
  11. 	SListPushBack(&plist, 5);
  12. 	SListPrint(plist);
  13.  
  14. 	SListPopBack(&plist);//尾删
  15. 	SListPrint(plist);
  16. 	SListPopBack(&plist);
  17. 	SListPrint(plist);
  18. 	SListPopBack(&plist);
  19. 	SListPrint(plist);
  20. 	SListPopBack(&plist);
  21. 	SListPrint(plist);
  22. 	SListPopBack(&plist);
  23. 	SListPrint(plist);
  24.  
  25. 	SListPushFront(&plist, 1);//依次头插1，2，3，4，5
  26. 	SListPrint(plist);
  27. 	SListPushFront(&plist, 2);
  28. 	SListPrint(plist);
  29. 	SListPushFront(&plist, 3);
  30. 	SListPrint(plist);
  31. 	SListPushFront(&plist, 4);
  32. 	SListPrint(plist);
  33. 	SListPushFront(&plist, 5);
  34. 	SListPrint(plist);
  35.  
  36. 	SListInsertAfter(SListFind(plist, 3), 7);//在3后面插入7
  37. 	SListPrint(plist);
  38. 	printf("节点数为 %d\n", SListSize(plist));
  39. 	SListInsertAfter(SListFind(plist, 1), 8);//在1后面插入8
  40. 	SListPrint(plist);
  41. 	printf("节点数为 %d\n", SListSize(plist));
  42. 	SListInsertAfter(SListFind(plist, 2), 9);//在2后面插入9
  43. 	SListPrint(plist);
  44. 	printf("节点数为 %d\n", SListSize(plist));
  45.  
  46. 	SListEraseAfter(SListFind(plist, 3));//删除3后面的元素
  47. 	SListPrint(plist);
  48. 	printf("节点数为 %d\n", SListSize(plist));
  49. 	SListEraseAfter(SListFind(plist, 1));//删除1后面的元素
  50. 	SListPrint(plist);
  51. 	printf("节点数为 %d\n", SListSize(plist));
  52. 	SListEraseAfter(SListFind(plist, 2));//删除2后面的元素
  53. 	SListPrint(plist);
  54. 	printf("节点数为 %d\n", SListSize(plist));
  55.  
  56. 	SListInsertBefore(&plist, SListFind(plist, 1), 6);//在1之前插入元素6
  57. 	SListPrint(plist);
  58. 	printf("节点数为 %d\n",SListSize(plist));
  59.  
  60. }
  61. void TestSList2()
  62. {
  63. 	SListNode* plist = NULL;//单链表的起始位置保存
  64.  
  65. //插入第一个节点时需要在此函数中通过形参来达到修改plist指向的修改
  66. 	SListPushBack(&plist, 1);//依次尾插1，2，3，4，5
  67. 	SListPrint(plist);
  68. 	SListPushBack(&plist, 2);
  69. 	SListPushBack(&plist, 3);
  70. 	SListPushBack(&plist, 4);
  71. 	SListPushBack(&plist, 5);
  72. 	SListPrint(plist);
  73.  
  74. 	SListPopBack(&plist);//尾删
  75. 	SListPrint(plist);
  76. 	SListPopBack(&plist);
  77. 	SListPrint(plist);
  78. 	SListPopBack(&plist);
  79. 	SListPrint(plist);
  80. 	SListPopBack(&plist);
  81. 	SListPrint(plist);
  82. 	SListPopBack(&plist);
  83. 	SListPrint(plist);
  84.  
  85. 	SListPushFront(&plist, 1);//依次头插1，2，3，4，5
  86. 	SListPrint(plist);
  87. 	SListPushFront(&plist, 2);
  88. 	SListPrint(plist);
  89. 	SListPushFront(&plist, 3);
  90. 	SListPrint(plist);
  91. 	SListPushFront(&plist, 4);
  92. 	SListPrint(plist);
  93. 	SListPushFront(&plist, 5);
  94. 	SListPrint(plist);
  95.  
  96. 	SListPopFront(&plist);//头删
  97. 	SListPrint(plist);
  98. 	printf("节点数为 %d\n", SListSize(plist));
  99. 	SListPopFront(&plist);
  100. 	SListPrint(plist);
  101. 	printf("节点数为 %d\n", SListSize(plist));
  102. 	SListPopFront(&plist);
  103. 	SListPrint(plist);
  104. 	printf("节点数为 %d\n", SListSize(plist));
  105. 	SListPopFront(&plist);
  106. 	SListPrint(plist);
  107. 	printf("节点数为 %d\n", SListSize(plist));
  108. 	SListPopFront(&plist);
  109. 	SListPrint(plist);
  110. 	printf("节点数为 %d\n", SListSize(plist));
  111. }

 

本文全部代码：

SList.h

  1. #pragma once
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <assert.h>
  5. typedef int SLTDataType;
  6. typedef struct SListNode
  7. {
  8. 	SLTDataType data;
  9. 	struct SListNode* next;
  10. }SListNode;
  11. //动态申请一个节点
  12. SListNode* BuySListNode(SLTDataType x);
  13. //单链表的尾插
  14. void SListPushBack(SListNode** pplist, SLTDataType x);
  15. //单链表的尾删
  16. void SListPopBack(SListNode** pplist);
  17. //链表打印
  18. void SListPrint(SListNode* plist);
  19.  
  20. // 单链表的头插
  21. void SListPushFront(SListNode** pplist, SLTDataType x);
  22. // 单链表头删
  23. void SListPopFront(SListNode** pplist);
  24. // 单链表查找
  25. SListNode* SListFind(SListNode* plist, SLTDataType x);
  26. // 单链表在pos位置之后插入x
  27. // 分析思考为什么不在pos位置之前插入？
  28. void SListInsertAfter(SListNode* pos, SLTDataType x);
  29. // 单链表删除pos位置之后的值
  30. // 分析思考为什么不删除pos位置？
  31. void SListEraseAfter(SListNode* pos);
  32. // 单链表的销毁
  33. void SListDestroy(SListNode** plist);

SList.c 

  1. #include "SList.h"
  2. //动态申请一个节点
  3. SListNode* BuySListNode(SLTDataType x)
  4. {
  5. 	SListNode* newNode = (SListNode *) malloc(sizeof(SListNode));//这个动态内存空间是用来存放这个结构体类型的
  6. 	if (NULL == newNode)
  7. 	{
  8. 		printf("创建节点失败！！！！");
  9. 		exit(0);
  10. 	}
  11. 	newNode->data = x;
  12. 	newNode->next = NULL;
  13. 	return newNode;
  14. }
  15. //单链表的尾插
  16. void SListPushBack(SListNode** pplist, SLTDataType x)
  17. {
  18. 	//若为空链表则需要让pplist指向刚刚插入的节点
  19. 	if (NULL == *pplist)
  20. 	{
  21. 		*pplist = BuySListNode(x);
  22. 	}
  23. 	else
  24. 	{
  25. 		//此时链表不为空
  26. 		//1.构建一个新节点
  27. 		SListNode* newNode = BuySListNode(x);
  28. 		//2.找原链表中最后一个节点
  29. 		SListNode* cur = *pplist;
  30. 		while (cur->next)
  31. 		{
  32. 			//获取cur的下一个节点
  33. 			cur = cur->next;
  34. 		}
  35. 		//3.插入新节点
  36. 		cur->next = newNode;
  37. 	}
  38. }
  39. //单链表的尾删
  40. void SListPopBack(SListNode** pplist)
  41. {
  42. 	assert(pplist);
  43. 	     //1.空链表
  44. 	if (NULL == *pplist)
  45. 	{
  46. 		return;
  47. 	}
  48. 	else if(NULL == (*pplist)->next)
  49. 	{
  50. 		//2.链表中只有一个节点
  51. 		free(*pplist);
  52. 		*pplist = NULL;
  53. 	}
  54. 	else
  55. 	{
  56.         //3.链表中有多个节点
  57.  
  58. 		SListNode* cur = *pplist;//*pplist为第一个节点
  59. 		while (cur->next->next)
  60. 		{
  61. 			cur = cur->next;
  62. 		}
  63. 		free(cur->next);
  64. 		cur->next = NULL;
  65. 		//方法2
  66. 		/*
  67. 		SListNode* cur = *pplist;//*pplist为第一个节点
  68. 		SListNode* prev = NULL;
  69. 		while (cur->next)
  70. 		{
  71. 		    prve = cur;
  72. 			cur = cur->next;
  73. 		}
  74. 		free(cur);
  75. 		prve->next = NULL;
  76. 		*/
  77. 	}
  78. 	    
  79.  
  80. }
  81. //链表打印
  82. void SListPrint(SListNode* plist)
  83. {
  84. 	SListNode* cur = plist;
  85. 	while (cur)
  86. 	{
  87. 		printf("%d--->", cur->data);
  88. 		cur = cur->next;
  89. 	}
  90. 	printf("NULL\n");
  91. }
  92. // 单链表的头插
  93. //时间复杂度：O(1)
  94. void SListPushFront(SListNode** pplist, SLTDataType x)
  95. {
  96. 	assert(pplist);
  97. 	SListNode* newNode = BuySListNode(x);
  98. 	1.链表为空
  99. 	//if (NULL == *pplist)
  100. 	//{
  101. 	//	*pplist = newNode;
  102. 	//}
  103. 	//else
  104. 	//{
  105. 	//	//2.链表不空
  106. 	//	newNode->next = *pplist;
  107. 	//	*pplist = newNode;
  108. 	//}
  109. 	//表面看上需要分情况讨论，但是在分析之后情况一可以与情况二合并
  110.  
  111. 	newNode->next = *pplist;
  112. 	*pplist = newNode;
  113. }
  114. //单链表查找
  115. SListNode* SListFind(SListNode* plist, SLTDataType x)
  116. {
  117. 	SListNode* cur = plist;
  118. 	while (cur)
  119. 	{
  120. 		if (cur->data == x)
  121. 		{
  122. 			return cur;
  123. 		}
  124. 		cur = cur->next;
  125. 	}
  126. 	return NULL;
  127. }
  128. //单链表中的有效节点数
  129. int SListSize(SListNode* plist)
  130. {
  131. 	int size = 0;
  132. 	SListNode* cur = plist;
  133. 	while (cur)
  134. 	{
  135. 		size++;
  136. 		cur = cur->next;
  137. 	}
  138. 	return size;
  139. }
  140. //单链表头删
  141. void SListPopFront(SListNode** pplist)
  142. {
  143. 	assert(pplist);
  144. 	SListNode* del = NULL;
  145. 	//1.链表为空
  146. 	if (NULL == *pplist)
  147. 	{
  148. 		return;
  149. 	}
  150. 	//else if (NULL == (*pplist)->next)
  151. 	//{
  152. 	//	//2.链表只有一个节点
  153. 	//	free(*pplist);
  154. 	//	*pplist = NULL;
  155. 	//}
  156. 	else
  157. 	{
  158. 		//3.链表中有多个节点(分析后可知也包含一个节点的情况)
  159. 		SListNode* del = *pplist;//将要删除的节点保存起来
  160. 		*pplist = (*pplist)->next;
  161. 		free(del);
  162. 	}
  163.  
  164. }
  165. //单链表在任意位置pos之后插入
  166. //新节点无法插入到pos之前，因为该方法未提供plist头节点
  167. //时间复杂度：O(1)
  168. void SListInsertAfter(SListNode* pos, SLTDataType x)
  169. {
  170. 	SListNode* newNode = NULL;
  171. 	if (NULL == pos)
  172. 	{
  173. 		return;
  174. 	}
  175. 	newNode = BuySListNode(x);
  176. 	newNode->next = pos->next;//必须先让新节点接入到链表内然后将pos位置的节点指向新节点
  177. 	pos->next = newNode;
  178. }
  179. //单链表在任意位置pos之前插入
  180. void SListInsertBefore(SListNode** pplist, SListNode* pos, SLTDataType x)
  181. {
  182. 	assert(pplist);
  183. 	assert(pos);
  184. 	SListNode* newNode = NULL;
  185. 	if (pos == *pplist)
  186. 	{
  187. 		newNode = BuySListNode(x);
  188. 	}
  189. 	else
  190. 	{	
  191. 		SListNode* cur = *pplist;//将头节点保存起来，**pplist是plist的地址，*plist才是解引用后的指针
  192. 		while (cur->next != pos)
  193. 		{
  194. 			cur = cur->next;
  195. 		}
  196. 		newNode = BuySListNode(x);
  197. 		newNode->next = pos;
  198. 		cur->next = newNode;
  199. 	}
  200. }
  201. // 单链表删除pos位置之后的值
  202. //时间复杂度O(1)
  203. void SListEraseAfter(SListNode* pos)
  204. {
  205. 	SListNode* delNode = NULL;
  206. 	if (NULL == pos)
  207. 	{
  208. 		return;
  209. 	}
  210. 	delNode = pos->next;
  211. 	if (NULL == delNode)
  212. 	{
  213. 		return;
  214. 	}
  215. 	//pos->data = delNode->data;
  216. 	pos->next = delNode->next;
  217. 	free(delNode);
  218. }
  219. //单链表销毁
  220. void SListDestroy(SListNode** pplist)
  221. {
  222. 	assert(pplist);
  223. 	SListNode* cur = *pplist;
  224. 	while (cur)
  225. 	{
  226. 		*pplist = cur->next;
  227. 		free(cur);
  228. 		cur = *pplist;
  229. 	}
  230. 	*pplist = NULL;
  231. }
  232.  
  233.  
  234. void TestSList1()
  235. {
  236. 	SListNode* plist = NULL;//单链表的起始位置保存
  237.  
  238. 	//插入第一个节点时需要在此函数中通过形参来达到修改plist指向的修改
  239. 	SListPushBack(&plist, 1);//依次尾插1，2，3，4，5
  240. 	SListPrint(plist);
  241. 	SListPushBack(&plist, 2);
  242. 	SListPushBack(&plist, 3);
  243. 	SListPushBack(&plist, 4);
  244. 	SListPushBack(&plist, 5);
  245. 	SListPrint(plist);
  246.  
  247. 	SListPopBack(&plist);//尾删
  248. 	SListPrint(plist);
  249. 	SListPopBack(&plist);
  250. 	SListPrint(plist);
  251. 	SListPopBack(&plist);
  252. 	SListPrint(plist);
  253. 	SListPopBack(&plist);
  254. 	SListPrint(plist);
  255. 	SListPopBack(&plist);
  256. 	SListPrint(plist);
  257.  
  258. 	SListPushFront(&plist, 1);//依次头插1，2，3，4，5
  259. 	SListPrint(plist);
  260. 	SListPushFront(&plist, 2);
  261. 	SListPrint(plist);
  262. 	SListPushFront(&plist, 3);
  263. 	SListPrint(plist);
  264. 	SListPushFront(&plist, 4);
  265. 	SListPrint(plist);
  266. 	SListPushFront(&plist, 5);
  267. 	SListPrint(plist);
  268.  
  269. 	SListInsertAfter(SListFind(plist, 3), 7);//在3后面插入7
  270. 	SListPrint(plist);
  271. 	printf("节点数为 %d\n", SListSize(plist));
  272. 	SListInsertAfter(SListFind(plist, 1), 8);//在1后面插入8
  273. 	SListPrint(plist);
  274. 	printf("节点数为 %d\n", SListSize(plist));
  275. 	SListInsertAfter(SListFind(plist, 2), 9);//在2后面插入9
  276. 	SListPrint(plist);
  277. 	printf("节点数为 %d\n", SListSize(plist));
  278.  
  279. 	SListEraseAfter(SListFind(plist, 3));//删除3后面的元素
  280. 	SListPrint(plist);
  281. 	printf("节点数为 %d\n", SListSize(plist));
  282. 	SListEraseAfter(SListFind(plist, 1));//删除1后面的元素
  283. 	SListPrint(plist);
  284. 	printf("节点数为 %d\n", SListSize(plist));
  285. 	SListEraseAfter(SListFind(plist, 2));//删除2后面的元素
  286. 	SListPrint(plist);
  287. 	printf("节点数为 %d\n", SListSize(plist));
  288.  
  289. 	SListInsertBefore(&plist, SListFind(plist, 1), 6);//在1之前插入元素6
  290. 	SListPrint(plist);
  291. 	printf("节点数为 %d\n",SListSize(plist));
  292.  
  293. }
  294. void TestSList2()
  295. {
  296. 	SListNode* plist = NULL;//单链表的起始位置保存
  297.  
  298. //插入第一个节点时需要在此函数中通过形参来达到修改plist指向的修改
  299. 	SListPushBack(&plist, 1);//依次尾插1，2，3，4，5
  300. 	SListPrint(plist);
  301. 	SListPushBack(&plist, 2);
  302. 	SListPushBack(&plist, 3);
  303. 	SListPushBack(&plist, 4);
  304. 	SListPushBack(&plist, 5);
  305. 	SListPrint(plist);
  306.  
  307. 	SListPopBack(&plist);//尾删
  308. 	SListPrint(plist);
  309. 	SListPopBack(&plist);
  310. 	SListPrint(plist);
  311. 	SListPopBack(&plist);
  312. 	SListPrint(plist);
  313. 	SListPopBack(&plist);
  314. 	SListPrint(plist);
  315. 	SListPopBack(&plist);
  316. 	SListPrint(plist);
  317.  
  318. 	SListPushFront(&plist, 1);//依次头插1，2，3，4，5
  319. 	SListPrint(plist);
  320. 	SListPushFront(&plist, 2);
  321. 	SListPrint(plist);
  322. 	SListPushFront(&plist, 3);
  323. 	SListPrint(plist);
  324. 	SListPushFront(&plist, 4);
  325. 	SListPrint(plist);
  326. 	SListPushFront(&plist, 5);
  327. 	SListPrint(plist);
  328.  
  329. 	SListPopFront(&plist);//头删
  330. 	SListPrint(plist);
  331. 	printf("节点数为 %d\n", SListSize(plist));
  332. 	SListPopFront(&plist);
  333. 	SListPrint(plist);
  334. 	printf("节点数为 %d\n", SListSize(plist));
  335. 	SListPopFront(&plist);
  336. 	SListPrint(plist);
  337. 	printf("节点数为 %d\n", SListSize(plist));
  338. 	SListPopFront(&plist);
  339. 	SListPrint(plist);
  340. 	printf("节点数为 %d\n", SListSize(plist));
  341. 	SListPopFront(&plist);
  342. 	SListPrint(plist);
  343. 	printf("节点数为 %d\n", SListSize(plist));
  344. }
  345.  
  346.  
  347.  
  348. int main()
  349. {
  350. 	//TestSList1();
  351. 	TestSList2();
  352. 	return 0;
  353. }

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

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

  

闽ICP备14008679号