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

【数据结构】第三站：单链表_listnode单链表

作者：小丑西瓜9 | 2024-05-01 01:42:40

赞

踩

listnode单链表

目录

一、顺序表的缺陷

二、链表

1.链表的概念以及结构

2.链表的分类

3.单链表的逻辑结构与物理结构

三、单链表的实现

1.单链表的定义

2.单链表的接口定义

3.单链表的接口实现

四、单链表的实现完整代码

一、顺序表的缺陷

在上一篇文章中，我们了解了顺序表的结构以及他的接口的实现。但同时我们也发现了他的一些缺陷

问题：
1. 中间/头部的插入删除，时间复杂度为O(N)
2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。
思考：如何解决以上问题呢？下面给出了链表的结构来看看

二、链表

1.链表的概念以及结构

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

2.链表的分类

链表一共有八种类型，他们可由是单向还是双向，是循环还是非循环，是带头结点还是不带头结点进行排列组合出八种结构

虽然有很多种结构，但是只有两种最为常用

无头单向非循环链表和带头双向循环链表

这里我们先只需要了解无头单向非循环链表，其他链表后续了解

3.单链表的逻辑结构与物理结构

如下图所示，是链表的实际的物理结构与逻辑结构。物理结构就是实实在在数据在内存中的变化，逻辑结构就是为了方便理解，形象化出来的

三、单链表的实现

1.单链表的定义

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

如上代码所示，单链表有数据域和指针域两部分组成，指针是用于指向下一个结点的指针

2.单链表的接口定义

  1. //单链表的打印
  2. void SListPrint(SListNode* plist);
  3. //单链表的尾插
  4. void SListPushBack(SListNode** pplist, SLTDateType x);
  5. //单链表的头插
  6. void SListPushFront(SListNode** pplist, SLTDateType x);
  7. //单链表的尾删
  8. void SListPopBack(SListNode** pplist);
  9. //单链表的头删
  10. void SListPopFront(SListNode** pplist);
  11. //单链表的查找
  12. SListNode* SListFind(SListNode* plist,SLTDateType x);
  13. //单链表在pos位置之后插入
  14. void SListInsertAfter(SListNode* pos, SLTDateType x);
  15. //单链表在pos位置之前插入
  16. void SListInsertPrev(SListNode** pplist, SListNode* pos, SLTDateType x);
  17. //单链表在pos之后删除
  18. void SListEraseAfter(SListNode* pos);
  19. //单链表在pos之前删除
  20. void SListErasePrev(SListNode** pplist, SListNode* pos);
  21. //单链表在pos位置删除
  22. void SListErase(SListNode** pplist, SListNode* pos);
  23. //单链表的销毁
  24. void SListDestroy(SListNode** pplist);

如上代码所示，是我们的单链表需要实现的接口，对于链表和顺序表一样都是为了实现数据的管理，区别就是前者是离散的，后者是连续的。我们的目的还是增删查改

3.单链表的接口实现

1.单链表的打印

  1. //单链表的打印
  2. void SListPrint(SListNode* plist)
  3. {
  4. 	SListNode* cur = plist;
  5. 	while (cur != NULL)
  6. 	{
  7. 		printf("%d->", cur->data);
  8. 		cur = cur->next;
  9. 	}
  10. 	printf("NULL\n");
  11. }

我们先来完成单链表的打印，对于单链表的打印，还是比较简单的，只需要先将头结点的指针给保存下来，然后依次去遍历单链表即可

2.单链表的尾插以及获取结点函数

  1. //获取一个结点
  2. SListNode* BuySListNode(SLTDateType x)
  3. {
  4. 	SListNode* tmp = (SListNode*)malloc(sizeof(SListNode));
  5. 	if (tmp == NULL)
  6. 	{
  7. 		perror("malloc fail");
  8. 		return;
  9. 	}
  10. 	tmp->next = NULL;
  11. 	tmp->data = x;
  12. 	return tmp;
  13. }
  14.  
  15. //单链表的尾插
  16. void SListPushBack(SListNode** pplist, SLTDateType x)
  17. {
  18. 	assert(pplist);
  19. 	SListNode* newnode = BuySListNode(x);
  20. 	if (*pplist == NULL)
  21. 	{
  22. 		*pplist = newnode;
  23. 		return;
  24. 	}
  25. 	SListNode* tail = (*pplist);
  26. 	while (tail->next != NULL)
  27. 	{
  28. 		tail = tail->next;
  29. 	}
  30. 	tail->next = newnode;
  31. }

对于单链表的尾插，我们要特别注意了。pplist是单链表头结点的地址，所以一定不为空

首先是获取结点，我们为了方便，先直接将其封装为一个函数。

有了结点了，那么我们还要思考如何尾插，那么我们先完成一般情况，假设已经有了一个很长的单链表了，我们还想要继续尾插一个值，那么只需要先找到原来的尾结点，然后将尾结点和新结点进行链接即可

当然还是存在一些特殊情况的，比如说原来的单链表压根就没有尾结点，也就是说链表是空的，那么上面的一般方法肯定行不通，这里其实就需要特殊处理一下，直接将新节点和链表头链接起来即可

3.单链表的头插

  1. //单链表的头插
  2. void SListPushFront(SListNode** pplist, SLTDateType x)
  3. {
  4. 	assert(pplist);
  5. 	SListNode* newnode = BuySListNode(x);
  6. 	SListNode* first = *pplist;
  7. 	*pplist = newnode;
  8. 	newnode->next = first;
  9. }

对于单链表的头插，就比较简单了，我们直接创建一个新结点，然后记录下原来的第一个结点的地址，然后让链表头与新节点链接起来，然后新节点与原来的第一个结点链接起来，这里我们会发下，其实是不需要处理空链表的情况的，这里体现了单链表适合头插

4.单链表的尾删

  1. //单链表的尾删
  2. void SListPopBack(SListNode** pplist)
  3. {
  4. 	assert(pplist);
  5. 	assert(*pplist);
  6. 	if ((*pplist)->next == NULL)
  7. 	{
  8. 		free(*pplist);
  9. 		*pplist = NULL;
  10. 	}
  11. 	else
  12. 	{
  13. 		SListNode* tail = *pplist;
  14. 		while (tail->next->next != NULL)
  15. 		{
  16. 			tail = tail->next;
  17. 		}
  18. 		free(tail->next);
  19. 		tail->next = NULL;
  20. 	}
  21. }

对于单链表的尾删，我们要想清楚了，首先是一般情况，当链表很长的时候，我们想要删除最后一个结点，那么得先找到前一个结点，然后释放最后一个结点，最后让前一个结点指向空。

我们还需要注意链表为空的状态，这个肯定是不可以删除的，所以我们直接断言掉。

然后是链表为一个结点的情况，如果链表只有一个结点，那么我们会发现，压根找不到前一个结点，所以我们也特殊处理，我们直接释放掉第一个结点，然后置空即可。

5.单链表的头删 

  1. //单链表的头删
  2. void SListPopFront(SListNode** pplist)
  3. {
  4. 	assert(pplist);
  5. 	assert(*pplist);
  6.  
  7. 	SListNode* second = (*pplist)->next;
  8. 	free(*pplist);
  9. 	*pplist = second;
  10. }

对于单链表的头删，我们同样断言掉链表为空的状态

然后我们需要做的就是记录第二个结点，然后释放原来的第一个结点，最后连接链表头和第二个结点。这样我们就实现了我们的目的。值得注意的是，我们发现链表的头删也是比较有优势的。

6.单链表的查找

  1. //单链表的查找
  2. SListNode* SListFind(SListNode* plist,SLTDateType x)
  3. {
  4. 	SListNode* cur = plist;
  5. 	while (cur != NULL)
  6. 	{
  7. 		if (cur->data == x)
  8. 		{
  9. 			return cur;
  10. 		}
  11. 		cur = cur->next;
  12. 	}
  13. 	return NULL;
  14. }

对于单链表的查找，这个也很简单，他和单链表的打印思路是一样的，不同的是只需要返回结点的地址即可。

7.单链表在pos位置之后的插入

  1. //单链表在pos位置之后插入
  2. void SListInsertAfter(SListNode* pos, SLTDateType x)
  3. {
  4. 	assert(pos);
  5. 	SListNode* newnode = BuySListNode(x);
  6. 	SListNode* next = pos->next;
  7. 	pos->next = newnode;
  8. 	newnode->next = next;
  9. }

单链表在pos位置之后的插入也是比较简单的，我们只需要先申请一个结点，然后记录pos位置的下一个结点，然后连接就可以了。值得注意的是，pos的位置不可能为空。因为他不是一个有效的结点地址

8.单链表在pos位置之前的插入

  1. //单链表在pos位置之前插入
  2. void SListInsertPrev(SListNode** pplist, SListNode* pos, SLTDateType x)
  3. {
  4. 	assert(pplist);
  5. 	assert(pos);
  6. 	assert(*pplist);
  7.  
  8. 	SListNode* newnode = BuySListNode(x);
  9. 	if (*pplist == pos)
  10. 	{
  11. 		*pplist = newnode;
  12. 		newnode->next = pos;
  13. 	}
  14. 	else
  15. 	{
  16. 		SListNode* prev = *pplist;
  17. 		while (prev->next != pos)
  18. 		{
  19. 			prev = prev->next;
  20. 		}
  21. 		prev->next = newnode;
  22. 		newnode->next = pos;
  23. 	}
  24. }

对于在pos位置之前的插入，确实是比较繁琐了。我们要思考，首先pos和pplist不可能为空，然后这个链表也是不可能为空链表的，至少也要有一个值。否则如果存在pos这个结点呢？

然后我们在来考虑一般情况，我们假设链表很长，在中间位置pos之前插入一个结点，那么毫无疑问的是，我们需要先申请一个结点，然后在通过遍历的方式要找到pos之前的那个结点。

有了这两个结点，那么我们就可以进行连接了。

然后是特殊情况，假如这个链表只有一个结点呢，这个结点正好就是pos，我们发现pos就没有前一个结点，其实这个就等效于头插。我们采用头插的方式即可

9.单链表在pos之后删除

  1. //单链表在pos之后删除
  2. void SListEraseAfter(SListNode* pos)
  3. {
  4. 	assert(pos);
  5. 	assert(pos->next);
  6. 	SListNode* next = pos->next;
  7. 	pos->next = next->next;
  8. 	free(next);
  9. 	next = NULL;
  10. }

单链表在pos之后删除的话，首先pos和pos的下一个结点不会为空，否则题目就矛盾了。所以我们得断言，然后我们直接记录pos 的下一个结点，然后连接pos和pos之后的结点。最后释放掉pos的下一个结点即可。

10.单链表在pos之前删除

  1. //单链表在pos之前删除
  2. void SListErasePrev(SListNode** pplist, SListNode* pos)
  3. {
  4. 	assert(pos);
  5. 	assert(pplist);
  6. 	assert(pos != *pplist);
  7. 	assert(*pplist);
  8.  
  9. 	if ((*pplist)->next == pos)
  10. 	{
  11. 		SListNode* del = *pplist;
  12. 		*pplist = pos;
  13. 		free(del);
  14. 		del = NULL;
  15. 	}
  16. 	else
  17. 	{
  18. 		SListNode* prev = *pplist;
  19. 		while (prev->next->next != pos)
  20. 		{
  21. 			prev = prev->next;
  22. 		}
  23. 		SListNode* del = prev->next;
  24. 		prev->next = pos;
  25. 		free(del);
  26. 		del = NULL;
  27. 	}
  28. }

对于单链表在pos之前删除确实就比较复杂了，首先pos，pplist，*pplist肯定不可能为空，然后pos也绝不可以是头节点，所以pos！=*pplist

我们现在来思考，假设一般情况，链表很长，在中间位置是pos，删除pos的前一个结点，那么我们就需要找到pos 的前一个的前一个结点。然后记录pos的前一个结点。释放pos 的前一个结点，然后进行连接即可

对于特殊情况，也就是，pos在第二个结点上，这样我们无法找到pos的前一个的前一个结点，但是这个就是头删，我们直接采用类似的思路即可

11.单链表在pos位置的删除

  1. //单链表在pos位置删除
  2. void SListErase(SListNode** pplist, SListNode* pos)
  3. {
  4. 	assert(pplist);
  5. 	assert(pos);
  6. 	assert(*pplist);
  7. 	
  8. 	if (*pplist == pos)
  9. 	{
  10. 		free(pos);
  11. 		*pplist = pos = NULL;
  12. 	}
  13. 	else
  14. 	{
  15. 		SListNode* prev = *pplist;
  16. 		while (prev->next != pos)
  17. 		{
  18. 			prev = prev->next;
  19. 		}
  20. 		prev->next = pos->next;
  21. 		free(pos);
  22. 		pos = NULL;
  23. 	}
  24. }

这个与上一个接口是基本一致的思路。不同的是，pos可以在头结点了，如果是头节点就是头删。

如果不是，就是先找到前一个结点，然后进行删除连接即可

12.单链表的销毁

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

对于单链表的销毁，这个也很简单，就直接遍历销毁即可，与打印和查找的思路是一致的

四、单链表的实现完整代码

SList.h文件

  1. #pragma once
  2.  
  3. #include<stdio.h>
  4. #include<stdlib.h>
  5. #include<malloc.h>
  6. #include<assert.h>
  7.  
  8. typedef int SLTDateType;
  9.  
  10. typedef struct SListNode
  11. {
  12. 	SLTDateType data;
  13. 	struct SListNode* next;
  14. }SListNode;
  15.  
  16. //单链表的打印
  17. void SListPrint(SListNode* plist);
  18. //单链表的尾插
  19. void SListPushBack(SListNode** pplist, SLTDateType x);
  20. //单链表的头插
  21. void SListPushFront(SListNode** pplist, SLTDateType x);
  22. //单链表的尾删
  23. void SListPopBack(SListNode** pplist);
  24. //单链表的头删
  25. void SListPopFront(SListNode** pplist);
  26. //单链表的查找
  27. SListNode* SListFind(SListNode* plist,SLTDateType x);
  28. //单链表在pos位置之后插入
  29. void SListInsertAfter(SListNode* pos, SLTDateType x);
  30. //单链表在pos位置之前插入
  31. void SListInsertPrev(SListNode** pplist, SListNode* pos, SLTDateType x);
  32. //单链表在pos之后删除
  33. void SListEraseAfter(SListNode* pos);
  34. //单链表在pos之前删除
  35. void SListErasePrev(SListNode** pplist, SListNode* pos);
  36. //单链表在pos位置删除
  37. void SListErase(SListNode** pplist, SListNode* pos);
  38. //单链表的销毁
  39. void SListDestroy(SListNode** pplist);

SList.c文件

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include"SList.h"
  3.  
  4. //单链表的打印
  5. void SListPrint(SListNode* plist)
  6. {
  7. 	SListNode* cur = plist;
  8. 	while (cur != NULL)
  9. 	{
  10. 		printf("%d->", cur->data);
  11. 		cur = cur->next;
  12. 	}
  13. 	printf("NULL\n");
  14. }
  15.  
  16. //获取一个结点
  17. SListNode* BuySListNode(SLTDateType x)
  18. {
  19. 	SListNode* tmp = (SListNode*)malloc(sizeof(SListNode));
  20. 	if (tmp == NULL)
  21. 	{
  22. 		perror("malloc fail");
  23. 		return;
  24. 	}
  25. 	tmp->next = NULL;
  26. 	tmp->data = x;
  27. 	return tmp;
  28. }
  29.  
  30. //单链表的尾插
  31. void SListPushBack(SListNode** pplist, SLTDateType x)
  32. {
  33. 	assert(pplist);
  34. 	SListNode* newnode = BuySListNode(x);
  35. 	if (*pplist == NULL)
  36. 	{
  37. 		*pplist = newnode;
  38. 		return;
  39. 	}
  40. 	SListNode* tail = (*pplist);
  41. 	while (tail->next != NULL)
  42. 	{
  43. 		tail = tail->next;
  44. 	}
  45. 	tail->next = newnode;
  46. }
  47.  
  48. //单链表的头插
  49. void SListPushFront(SListNode** pplist, SLTDateType x)
  50. {
  51. 	assert(pplist);
  52. 	SListNode* newnode = BuySListNode(x);
  53. 	SListNode* first = *pplist;
  54. 	*pplist = newnode;
  55. 	newnode->next = first;
  56. }
  57.  
  58. //单链表的尾删
  59. void SListPopBack(SListNode** pplist)
  60. {
  61. 	assert(pplist);
  62. 	assert(*pplist);
  63. 	if ((*pplist)->next == NULL)
  64. 	{
  65. 		free(*pplist);
  66. 		*pplist = NULL;
  67. 	}
  68. 	else
  69. 	{
  70. 		SListNode* tail = *pplist;
  71. 		while (tail->next->next != NULL)
  72. 		{
  73. 			tail = tail->next;
  74. 		}
  75. 		free(tail->next);
  76. 		tail->next = NULL;
  77. 	}
  78. }
  79.  
  80. //单链表的头删
  81. void SListPopFront(SListNode** pplist)
  82. {
  83. 	assert(pplist);
  84. 	assert(*pplist);
  85.  
  86. 	SListNode* second = (*pplist)->next;
  87. 	free(*pplist);
  88. 	*pplist = second;
  89. }
  90.  
  91. //单链表的查找
  92. SListNode* SListFind(SListNode* plist,SLTDateType x)
  93. {
  94. 	SListNode* cur = plist;
  95. 	while (cur != NULL)
  96. 	{
  97. 		if (cur->data == x)
  98. 		{
  99. 			return cur;
  100. 		}
  101. 		cur = cur->next;
  102. 	}
  103. 	return NULL;
  104. }
  105. //单链表在pos位置之后插入
  106. void SListInsertAfter(SListNode* pos, SLTDateType x)
  107. {
  108. 	assert(pos);
  109. 	SListNode* newnode = BuySListNode(x);
  110. 	SListNode* next = pos->next;
  111. 	pos->next = newnode;
  112. 	newnode->next = next;
  113. }
  114. //单链表在pos位置之前插入
  115. void SListInsertPrev(SListNode** pplist, SListNode* pos, SLTDateType x)
  116. {
  117. 	assert(pplist);
  118. 	assert(pos);
  119. 	assert(*pplist);
  120.  
  121. 	SListNode* newnode = BuySListNode(x);
  122. 	if (*pplist == pos)
  123. 	{
  124. 		*pplist = newnode;
  125. 		newnode->next = pos;
  126. 	}
  127. 	else
  128. 	{
  129. 		SListNode* prev = *pplist;
  130. 		while (prev->next != pos)
  131. 		{
  132. 			prev = prev->next;
  133. 		}
  134. 		prev->next = newnode;
  135. 		newnode->next = pos;
  136. 	}
  137. }
  138. //单链表在pos之后删除
  139. void SListEraseAfter(SListNode* pos)
  140. {
  141. 	assert(pos);
  142. 	assert(pos->next);
  143. 	SListNode* next = pos->next;
  144. 	pos->next = next->next;
  145. 	free(next);
  146. 	next = NULL;
  147. }
  148. //单链表在pos之前删除
  149. void SListErasePrev(SListNode** pplist, SListNode* pos)
  150. {
  151. 	assert(pos);
  152. 	assert(pplist);
  153. 	assert(pos != *pplist);
  154. 	assert(*pplist);
  155.  
  156. 	if ((*pplist)->next == pos)
  157. 	{
  158. 		SListNode* del = *pplist;
  159. 		*pplist = pos;
  160. 		free(del);
  161. 		del = NULL;
  162. 	}
  163. 	else
  164. 	{
  165. 		SListNode* prev = *pplist;
  166. 		while (prev->next->next != pos)
  167. 		{
  168. 			prev = prev->next;
  169. 		}
  170. 		SListNode* del = prev->next;
  171. 		prev->next = pos;
  172. 		free(del);
  173. 		del = NULL;
  174. 	}
  175. }
  176. //单链表在pos位置删除
  177. void SListErase(SListNode** pplist, SListNode* pos)
  178. {
  179. 	assert(pplist);
  180. 	assert(pos);
  181. 	assert(*pplist);
  182. 	
  183. 	if (*pplist == pos)
  184. 	{
  185. 		free(pos);
  186. 		*pplist = pos = NULL;
  187. 	}
  188. 	else
  189. 	{
  190. 		SListNode* prev = *pplist;
  191. 		while (prev->next != pos)
  192. 		{
  193. 			prev = prev->next;
  194. 		}
  195. 		prev->next = pos->next;
  196. 		free(pos);
  197. 		pos = NULL;
  198. 	}
  199. }
  200. //单链表的销毁
  201. void SListDestroy(SListNode** pplist)
  202. {
  203. 	SListNode* cur = *pplist;
  204. 	while (cur != NULL)
  205. 	{
  206. 		SListNode* next = cur->next;
  207. 		free(cur);
  208. 		cur = next;
  209. 	}
  210. }

Test.c文件

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2.  
  3. #include"Slist.h"
  4.  
  5. void TestSList1()
  6. {
  7. 	SListNode* phead = NULL;
  8. 	SListPushBack(&phead, 1);
  9. 	SListPushBack(&phead, 2);
  10. 	SListPushBack(&phead, 3);
  11. 	SListPushBack(&phead, 4);
  12. 	SListPushBack(&phead, 5);
  13. 	SListPrint(phead);
  14.  
  15. 	SListPushFront(&phead, 6);
  16. 	SListPushFront(&phead, 7);
  17. 	SListPushFront(&phead, 8);
  18. 	SListPushFront(&phead, 9);
  19. 	SListPushFront(&phead, 10);
  20. 	SListPrint(phead);
  21.  
  22. 	SListPopBack(&phead);
  23. 	SListPopBack(&phead);
  24. 	SListPopBack(&phead);
  25. 	SListPopBack(&phead);
  26. 	SListPrint(phead);
  27. 	SListPopBack(&phead);
  28. 	SListPrint(phead);
  29.  
  30. 	
  31.  
  32. }
  33. void TestSList2()
  34. {
  35. 	SListNode* phead = NULL;
  36. 	SListPushBack(&phead, 1);
  37. 	SListPushBack(&phead, 2);
  38. 	SListPushBack(&phead, 3);
  39. 	SListPushBack(&phead, 4);
  40. 	SListPushBack(&phead, 5);
  41. 	SListPrint(phead);
  42.  
  43. 	SListPopFront(&phead);
  44. 	SListPopFront(&phead);
  45. 	SListPopFront(&phead);
  46. 	SListPopFront(&phead);
  47. 	SListPrint(phead);
  48. 	SListPopFront(&phead);
  49. 	SListPrint(phead);
  50. }
  51. void TestSList3()
  52. {
  53. 	SListNode* phead = NULL;
  54. 	SListPushBack(&phead, 1);
  55. 	SListPushBack(&phead, 2);
  56. 	SListPushBack(&phead, 3);
  57. 	SListPushBack(&phead, 4);
  58. 	SListPushBack(&phead, 5);
  59. 	SListPrint(phead);
  60.  
  61. 	SListNode* pos = SListFind(phead, 3);
  62. 	pos->data = 100;
  63. 	SListPrint(phead);
  64. 	SListInsertAfter(pos, 200);
  65. 	SListInsertAfter(pos, 300);
  66. 	SListInsertAfter(pos, 400);
  67. 	SListInsertAfter(pos, 500);
  68. 	SListPrint(phead);
  69.  
  70. 	SListNode* pos2 = SListFind(phead, 1);
  71. 	SListInsertPrev(&phead, pos2, 101);
  72. 	SListInsertPrev(&phead, pos2, 102);
  73. 	SListInsertPrev(&phead, pos2, 103);
  74. 	SListInsertPrev(&phead, pos2, 104);
  75. 	SListPrint(phead);
  76.  
  77. 	SListEraseAfter(pos2);
  78. 	SListEraseAfter(pos2);
  79. 	SListEraseAfter(pos2);
  80. 	SListPrint(phead);
  81. 	
  82.  
  83. }
  84.  
  85.  
  86. void TestSList4()
  87. {
  88. 	SListNode* phead = NULL;
  89. 	SListPushBack(&phead, 1);
  90. 	SListPushBack(&phead, 2);
  91. 	SListPushBack(&phead, 3);
  92. 	SListPushBack(&phead, 4);
  93. 	SListPushBack(&phead, 5);
  94. 	SListPrint(phead);
  95.  
  96. 	SListNode* pos = SListFind(phead, 5);
  97.  
  98. 	SListErasePrev(&phead, pos);
  99. 	SListPrint(phead);
  100. 	SListErasePrev(&phead, pos);
  101. 	SListPrint(phead);
  102.  
  103.  
  104. 	SListErase(&phead, pos);
  105. 	SListPrint(phead);
  106.  
  107. 	SListDestroy(&phead);
  108. }
  109.  
  110. int main()
  111. {
  112. 	//TestSList1();
  113. 	//TestSList2();
  114. 	//TestSList3();
  115. 	TestSList4();
  116. 	return 0;
  117. }

本节内容到此位置，感谢您的阅读

如果对你有帮助的话，不要忘记点赞加收藏哦！！！

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/516347
推荐阅读
相关标签

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

  

闽ICP备14008679号