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

链表基础知识（一、单链表、头插、尾插、头删、尾删、查找、删除、插入、求表长，合并链表）_单链表的尾插

作者：黑客灵魂 | 2024-08-04 07:40:18

赞

踩

单链表的尾插

目录

一、链表表示和实现

1.1 链表的概念及结构 

二、链表的分类：

2.1实际中要实现的链表的结构非常多样，以下情况组合起来就有8种链表结构： 

2.2链表和顺序表的对比

三、单链表

3.1无头+单向+非循环链表增删查改实现

3.2SList.h 

3.3打印链表

3.4新建一个节点

3.5尾插

3.6头插

3.7头删

3.8尾删

链表为空：

只有一个节点时：

有多个节点时：

3.9查找

3.10在pos的前面插入

3.11删除pos位置的值

四、SList.c

五、Test.c

顺序表的实现(头插、尾插、头删、尾删、查找、删除、插入)-CSDN博客

链表基础知识（二、双向链表头插、尾插、头删、尾删、查找、删除、插入）-CSDN博客

一、链表表示和实现

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

1.1 链表的概念及结构 

概念：链表是一种物理存储结构上非连续、非顺序的存储结构，用于存储逻辑关系为 “一对一” 的数据。链表中每个数据的存储都由以下两部分组成：
  1.数据元素本身，其所在的区域称为数据域。
  2.指向直接后继元素的指针，所在的区域称为指针域。

   （单链表的节点）

数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。

 

1.2简易理解链表概念

 链表的结构跟火车车厢相似，淡季时车次的车厢会相应减少，旺季时车次的车厢会额外增加几节。只需要将火车里的某节车厢去掉/加上，不会影响其他车厢，每节车厢都是独立存在的。​

车厢是独立存在的，且每节车厢都有车门。想象一下这样的场景，假设每节车厢的车门都是锁上的状态，需要不同的钥匙才能解锁，每次只能携带一把钥匙的情况下如何从车头走到车尾？
最简单的做法：每节车厢里都放一把下一节车厢的钥匙。

1.21问：在链表里，每节“车厢”是什么样的呢？

如图：

与顺序表不同的是，链表里的每节"车厢"都是独立申请下来的空间，我们称之为“结点/节点”​
节点的组成主要有两个部分：当前节点要保存的数据和保存下一个节点的地址（指针变量）。
图中指针变量 plist保存的是第一个节点的地址，我们称plist此时“指向”第一个节点，如果我们希
望plist“指向”第二个节点时，只需要修改plist保存的内容为0x0012FFA0。​

1.22问：那为什么还需要指针变量来保存下一个节点的位置？

答：链表中每个节点都是独立申请的（即需要插入数据时才去申请一块节点的空间），我们需要通过指针变量来保存下一个节点位置才能从当前节点找到下一个节点。

结合前面学到的结构体知识，我们可以给出每个节点对应的结构体代码：
假设当前保存的节点为整型：

struct SListNode
{
 int data; //节点数据​
 struct SListNode* next; //指针变量用保存下一个节点的地址​
};

当我们想要保存一个整型数据时，实际是向操作系统申请了一块内存，这个内存不仅要保存整型数
据，也需要保存下一个节点的地址（当下一个节点为空时保存的地址为空）。
当我们想要从第一个节点走到最后一个节点时，只需要在前一个节点拿上下一个节点的地址（下一个        节点的钥匙）就可以了。

1.23给定的链表结构中，如何实现节点从头到尾的打印？

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

 

二、链表的分类：

2.1实际中要实现的链表的结构非常多样，以下情况组合起来就有8种链表结构： 

  • 头节点：是一个节点，本质上是一个结构体变量，区分数据域和指针域，不存放任何数据，只存放指向链表中真正存放数据的第一个节点的地址，仅用于辅助管理整个链表的结构。

  • 头指针：是一个指针，本质上是一个结构体类型的指针变量，不区分数据域和指针域，它仅存储链表中第一个节点的地址。

  • 带头节点也就意味着不需要传二级指针了

 

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

2.2链表和顺序表的对比

三、单链表

3.1单链表的优劣：

1、查找速度慢

2、 不能从后往前

3、找不到前驱

4、单向链表不能自我删除，需要靠辅助节点 。

3.1无头+单向+非循环链表增删查改实现

无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结
构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。

3.2DList.h 

  1. #pragma once //防止重复包含
  2. #include<stdio.h>
  3. #include<string.h>
  4. #include<stdlib.h>
  5. #include<assert.h>
  6.  
  7. typedef int SLTDataType;//方便改变数据类型
  8. struct SListNode
  9. {
  10. 	SLTDataType data;
  11. 	struct SListNode* next;//下一个地址
  12. 	//结构体中嵌套指针,但不能嵌套自己,会死循环
  13. }SLTNode;
  14. typedef struct SListNode STLNode;
  15.  
  16.  
  17. // 不会改变链表的头指针，传一级指针
  18. void SListPrint(STLNode* phead);
  19.  
  20. // 可能会改变链表的头指针，传二级指针
  21. void SListPushBack(STLNode** pphead, SLTDataType x);
  22. void SListPushFront(STLNode** pphead, SLTDataType x);//分有节点头插和无节点头插,尾插得分开处理
  23. void SListPopFront(STLNode** pphead);
  24. void SListPopBack(STLNode** pphead);
  25.  
  26. // 不会改变链表的头指针，传一级指针
  27. STLNode* SListFind(STLNode* pphead, SLTDataType x);
  28. // 在pos的前面插入x
  29. void SListInsert(STLNode** pphead, STLNode* pos, SLTDataType x);
  30. // 删除pos位置的值
  31. void SListErase(STLNode** pphead, STLNode* pos);
  32.  
  33.  
  34. 有些地方也有这样定义
  35.  在pos的前面插入x
  36. //void SListInsert(STLNode** phead, int i, SLTDataType x);
  37.  删除pos位置的值
  38. //void SListErase(STLNode** phead, int i);

3.3打印链表

第一步：输出第一个节点的数据域，输出完毕后，让指针保存后一个节点的地址

 第二步：输出移动地址对应的节点的数据域，输出完毕后，指针继续后移 

 第三步：以此类推，直到节点的指针域为NULL

  1. void SListPrint(STLNode* phead)
  2. {
  3. 	STLNode* cur = phead;
  4. 	while (cur != NULL)//第一个地址不为空
  5. 	{
  6. 		printf("%d->", cur->data);
  7. 		cur = cur->next;//令cur下一个地址
  8. 	}
  9. 	printf("NULL\n");
  10.  
  11. }

3.4新建一个节点

函数中的 malloc 用于在堆上分配内存。它返回一个指向新分配内存的指针，该指针被转换为 stlNode* 类型并存储在 newnode 变量中。这个新节点被初始化为包含一个 data 字段和一个 next 字段，其中 data 字段被设置为参数 x 的值，而 next 字段被初始化为 NULL。

  1. STLNode* BuySListNode(SLTDataType x)
  2. {
  3. 	STLNode* newnode = (STLNode*)malloc(sizeof(STLNode));
  4. 	newnode->data = x;
  5. 	newnode->next = NULL;
  6. }

3.5尾插

  1. void SListPushBack(STLNode** pphead, SLTDataType x)
  2. //void SListPushBack(STLNode*& pphead, SLTDataType x)
  3. //在					C++语法中可以加&,引用,别名
  4. {
  5. 	STLNode* newnode = (STLNode*)malloc(sizeof(STLNode));
  6. 	newnode->data = x;
  7. 	newnode->next = NULL;
  8. 	
  9. 	// 找尾节点的指针
  10. 	if (*pphead == NULL)//pphead是plist的地址
  11. 	{
  12. 		*pphead = newnode;//在尾部创建新节点
  13. 	}
  14. 	else {
  15. 		STLNode* tail = *pphead;//phead在开始时为空
  16. 		while (tail->next != NULL)//判断下一个指针是否为空
  17. 		{
  18. 			tail = tail->next;//指向下一个节点
  19. 		}
  20.  
  21. 		// 尾节点，链接新节点
  22. 		tail->next = newnode;
  23. 	}
  24. }

3.6头插

  1. void SListPushFront(STLNode** pphead, SLTDataType x)
  2. {
  3. 	STLNode* newnode = BuySListNode(x);//新建一个节点
  4. 	newnode->next = *pphead;//在第一个地址前建立一个新节点
  5. 	*pphead = newnode;//使新节点变为第一个地址
  6. }

3.7头删

  1. void SListPopFront(STLNode** pphead)
  2. {
  3. 	STLNode* next = (*pphead)->next;//保存下一个地址
  4. 	free(*pphead);//释放空间
  5. 	*pphead = next;//令其指针指向下一个地址
  6. }

3.8尾删

 尾删的目的是从给定的单链表中删除最后一个节点，所以分三种情况：

1、链表为空        

2、链表只有一个节点        

3、链表有多个节点

链表为空：

如果链表为空（*pphead == NULL），那么就没有什么可以删除的内容，所以函数直接返回。

只有一个节点时：

有多个节点时：

如果链表有多个节点，我们需要找到链表的最后一个节点，并删除它。为了找到最后一个节点，我们设置两个指针 prev 和 tail，开始时都指向链表头。然后我们遍历链表，直到找到最后一个节点。找到后，我们释放最后一个节点的内存，然后把倒数第二个节点的 next 设置为 NULL，表示链表最后一个节点已经被删除。

  1. void SListPopBack(STLNode** pphead)
  2. {
  3. 	//1.空
  4. 	//2.一个节点
  5. 	//3.一个以上节点
  6. 	if (*pphead == NULL)//1.空
  7.     //如果为空，说明链表已经为NULL，没有可以删除的内容了
  8. 	{
  9. 		return;
  10. 	}
  11. 	else if ((*pphead)->next == NULL)//2.一个节点
  12. 	{
  13. 		free(*pphead);//1.先释放
  14. 		*pphead = NULL;//2.把plist置成空
  15. 	}
  16. 	else {
  17.         //3.一个以上节点
  18. 		STLNode* prev = NULL;
  19. 		STLNode* tail = *pphead;
  20. 		while (tail->next != NULL)
  21. 		{
  22. 			prev = tail;
  23. 			tail = tail->next;
  24. 		}
  25. 		free(tail);
  26. 		prev->next = NULL;
  27. 	
  28. 	}
  29. }

3.9查找

其实就是遍历一遍链表，但是只能返回第一次出现的地址。我们查找到节点的地址后就可以通过地址去修改数据域中存储的数据。

  1. TLNode* SListFind(STLNode* phead, SLTDataType x)
  2. {
  3. 	STLNode* cur = phead;
  4. 	while (cur != NULL)
  5. 	//while (cur)
  6. 	{
  7. 		if (cur->data = x)
  8. 		{
  9. 			return cur;//找到了
  10. 		}
  11. 		cur = cur->next;
  12. 	}
  13. 	return NULL;
  14. }

3.10在pos的前面插入

  • //创建新节点 stlNode* newnode = BuySListNode(x); 

  • // 初始时，prev 指向链表的头节点 pphead。 stlNode* prev = *pphead;

  • while (cur != pos) // 这个 while 循环用于找到 pos 节点。  

  • prev = prev->next; cur = cur->next; //如果 cur 不等于 pos，那么移动 prev 和 cur。prev 移动到 cur 的下一个节点。cur 移动到下一个节点。

  • prev->next = newnode;//现在，prev 指向 pos 的前一个节点，cur 指向 pos 节点本身。我们将新节点插入到 prev 和 cur 之间。

  • prev->next = newnode; // 然后，我们将新节点的 next 指向 pos，这样新节点就位于 pos 之前了。

  1. void SListInsert(STLNode** pphead, STLNode* pos, SLTDataType x)
  2. {
  3. 	if (pos == *pphead)
  4. 	{
  5. 		SListPushFront(pphead, x);
  6. 	}
  7. 	else {
  8. 		STLNode* newnode = BuySListNode(x);
  9. 		STLNode* prev = *pphead;
  10. 		/*while (prev->next != pos)*/
  11. 		STLNode* cur = *pphead;
  12. 		while (cur != pos)
  13. 		{
  14. 			prev = prev->next;
  15. 		}
  16. 		prev->next = newnode;
  17. 		newnode->next = pos;
  18. 	
  19. 	}
  20. }

3.11删除pos位置的值

  1. void SListErase(STLNode** pphead, STLNode* pos)
  2. {
  3. 	if (pos == *pphead)//如果要删除的是头节点
  4. 	{
  5. 		SListPopFront(pphead);//头删
  6. 	}
  7. 	else {
  8. 		STLNode* prev = *pphead;
  9. 		while (prev->next != pos)
  10. 		{
  11. 			prev = prev->next;
  12. 		}
  13. 		prev->next = pos->next;//删除指定位置的节点
  14. 		free(pos);//释放要删除节点的内存
  15. 	}
  16. }

3.12求链表长度

  1.  
  2. // 计算长度
  3. void lengthList(STLNode* phead) {
  4. 	STLNode* p;
  5. 	int len = 0;        // 计数器
  6. 	p = phead->next;
  7. 	if (!p) return;  // 空链表
  8. 	while (p) {
  9. 		len++;
  10. 		p = p->next;
  11. 	}
  12. 	printf("链表的长度=%d", len);
  13. }

3.13合并链表

  1. typedef int SLTDataType;//方便改变数据类型
  2. struct SListNode
  3. {
  4. 	SLTDataType data;
  5. 	struct SListNode* next;//下一个地址
  6. 	//结构体中嵌套指针,但不能嵌套自己,会死循环
  7. }SLTNode;
  8. typedef struct SListNode STLNode;
  9.  
  10. void SListPushBack(STLNode** pphead, SLTDataType x)
  11. {
  12. 	STLNode* newnode = (STLNode*)malloc(sizeof(SListNode));
  13. 	newnode->data = x;
  14. 	newnode->next = NULL;
  15. 	if (*pphead == NULL)
  16. 	{
  17. 		*pphead = newnode;
  18. 	}
  19. 	else {
  20. 		STLNode* tail = *pphead;
  21. 		while (tail->next != NULL)
  22. 		{
  23. 			tail = tail->next;
  24. 		}
  25. 		tail->next = newnode;
  26. 	}
  27. }
  28.  
  29. STLNode* TestSList1()
  30. {
  31. 	STLNode* plistA = NULL;//先让plist指向空
  32. 	SListPushBack(&plistA, 1);
  33. 	SListPushBack(&plistA, 2);
  34. 	SListPushBack(&plistA, 5);
  35. 	SListPushBack(&plistA, 7);
  36. 	SListPushBack(&plistA, 10);
  37. 	return plistA;
  38. }
  39.  
  40. STLNode* TestSList2()
  41. {
  42. 	STLNode* plistB = NULL;//先让plist指向空
  43. 	SListPushBack(&plistB, 1);
  44. 	SListPushBack(&plistB, 2);
  45. 	SListPushBack(&plistB, 3);
  46. 	SListPushBack(&plistB, 4);
  47. 	SListPushBack(&plistB, 5);
  48. 	SListPushBack(&plistB, 7);
  49. 	SListPushBack(&plistB, 9);
  50.  
  51. 	return plistB;
  52. }
  53.  
  54. STLNode* mergelists(STLNode* plistA, STLNode* plistB) {
  55. 	STLNode* plist = (STLNode*)malloc(sizeof(SLTDataType));
  56. 	STLNode* cur = plist;   
  57. 	plist->next = NULL;
  58. 	plist->data = NULL;
  59. 	while (plistA != NULL && plistB != NULL) {
  60. 		
  61. 		if(plistA->data < plistB->data)
  62. 		{
  63. 			cur->next = plistA;
  64. 			plistA = plistA->next;
  65. 		}
  66. 		else if (plistA->data > plistB->data)
  67. 		{
  68. 			cur->next = plistB;
  69. 			plistB = plistB->next;
  70. 		}
  71. 		else {  
  72. 			cur->next = plistA;
  73. 			plistA = plistA->next;
  74. 			plistB = plistB->next;
  75. 		}
  76. 		cur = cur->next;
  77. 	}
  78.  
  79. 	cur->next = plistA == NULL ? plistB : plistA; 
  80. 	return plist->next;   
  81. }
  82.  
  83. void SListPrint(STLNode* phead)
  84. {
  85. 	STLNode* cur = phead;
  86. 	while (cur != NULL)//phead不为空
  87. 	{
  88. 		printf("%d->", cur->data);
  89. 		cur = cur->next;//令cur指向phead中的地址,即下一个节点的地址
  90. 	}
  91. 	printf("NULL\n");
  92.  
  93. }
  94.  
  95. int main()
  96. {
  97. 	STLNode* p1 = TestSList1();
  98. 	STLNode* p2 = TestSList2();
  99. 	SListPrint(p1);
  100. 	SListPrint(p2);
  101. 	STLNode* res =  mergelists(p1, p2);
  102. 	SListPrint(res);
  103. }

四、DList.c

  1. #include"SeqList.h"
  2.  
  3. void SListPrint(STLNode* phead)
  4. {
  5. 	STLNode* cur = phead;
  6. 	while (cur != NULL)//第一个地址不为空
  7. 	{
  8. 		printf("%d->", cur->data);
  9. 		cur = cur->next;//令cur下一个地址
  10. 	}
  11. 	printf("NULL\n");
  12.  
  13. }
  14.  
  15. STLNode* BuySListNode(SLTDataType x)
  16. {
  17. 	STLNode* newnode = (STLNode*)malloc(sizeof(STLNode));
  18. 	newnode->data = x;
  19. 	newnode->next = NULL;
  20. }
  21.  
  22. //尾插
  23. void SListPushBack(STLNode** pphead, SLTDataType x)
  24. //void SListPushBack(STLNode*& pphead, SLTDataType x)
  25. //在					C++语法中可以加&,引用,别名
  26. {
  27. 	STLNode* newnode = (STLNode*)malloc(sizeof(STLNode));
  28. 	newnode->data = x;
  29. 	newnode->next = NULL;
  30. 	
  31. 	// 找尾节点的指针
  32. 	if (*pphead == NULL)//pphead是plist的地址
  33. 	{
  34. 		*pphead = newnode;
  35. 	}
  36. 	else {
  37. 		STLNode* tail = *pphead;//phead在开始时为空
  38. 		while (tail->next != NULL)//判断下一个指针是否为空
  39. 		{
  40. 			tail = tail->next;
  41. 		}
  42.  
  43. 		// 尾节点，链接新节点
  44. 		tail->next = newnode;
  45. 	}
  46. }
  47.  
  48.  
  49. void SListPushFront(STLNode** pphead, SLTDataType x)
  50. {
  51. 	STLNode* newnode = BuySListNode(x);
  52. 	newnode->next = *pphead;
  53. 	*pphead = newnode;
  54. }
  55.  
  56.  
  57. void SListPopFront(STLNode** pphead)
  58. {
  59. 	STLNode* next = (*pphead)->next;//保存下一个地址
  60. 	free(*pphead);//释放空间
  61. 	*pphead = next;//令其指针指向下一个地址
  62. }
  63.  
  64. void SListPopBack(STLNode** pphead)
  65. {
  66. 	//1.空
  67. 	//2.一个节点
  68. 	//3.一个以上节点
  69. 	if (*pphead == NULL)
  70. 	{
  71. 		return;
  72. 	}
  73. 	else if ((*pphead)->next == NULL)
  74. 	{
  75. 		free(*pphead);//1.先释放
  76. 		*pphead = NULL;//2.把plist置成空
  77. 	}
  78. 	else {
  79. 		STLNode* prev = NULL;
  80. 		STLNode* tail = *pphead;
  81. 		while (tail->next != NULL)
  82. 		{
  83. 			prev = tail;
  84. 			tail = tail->next;
  85. 		}
  86. 		free(tail);
  87. 		prev->next = NULL;
  88. 	
  89. 	}
  90. }
  91.  
  92.  
  93. STLNode* SListFind(STLNode* phead, SLTDataType x)
  94. {
  95. 	STLNode* cur = phead;
  96. 	while (cur != NULL)
  97. 	//while (cur)
  98. 	{
  99. 		if (cur->data = x)
  100. 		{
  101. 			return cur;//找到了
  102. 		}
  103. 		cur = cur->next;
  104. 	}
  105. 	return NULL;
  106. }
  107.  
  108. // 在pos的前面插入x
  109. void SListInsert(STLNode** pphead, STLNode* pos, SLTDataType x)
  110. {
  111. 	if (pos == *pphead)
  112. 	{
  113. 		SListPushFront(pphead, x);
  114. 	}
  115. 	else {
  116. 		STLNode* newnode = BuySListNode(x);
  117. 		STLNode* prev = *pphead;
  118. 		/*while (prev->next != pos)*/
  119. 		STLNode* cur = *pphead;
  120. 		while (cur != pos)
  121.  
  122. 		{
  123. 			prev = prev->next;
  124. 		}
  125. 		prev->next = newnode;
  126. 		newnode->next = pos;
  127. 	
  128. 	}
  129. }
  130. // 删除pos位置的值
  131. void SListErase(STLNode** pphead, STLNode* pos)
  132. {
  133. 	if (pos == *pphead)
  134. 	{
  135. 		SListPopFront(pphead);
  136. 	}
  137. 	else {
  138. 		STLNode* prev = *pphead;
  139. 		while (prev->next != pos)
  140. 		{
  141. 			prev = prev->next;
  142. 		}
  143. 		prev->next = pos->next;
  144. 		free(pos);
  145. 	}
  146. }

五、Test.c

  1. #include"SeqList.h"
  2.  
  3. void TestSList1()
  4. {
  5. 	STLNode* plist = NULL;//先让plist指向空
  6. 	SListPushBack(&plist, 1);
  7. 	SListPushBack(&plist, 2);
  8. 	//插入几个值,用节点存起来
  9. 	SListPushBack(&plist, 3);
  10. 	SListPushBack(&plist, 4);
  11. 	SListPushFront(&plist, 0);
  12. 	SListPrint(plist);
  13. 	
  14. 	SListPopFront(&plist);
  15. 	SListPopFront(&plist);
  16. 	SListPopFront(&plist);
  17. 	SListPrint(plist);
  18. 	
  19. 	SListPopFront(&plist);
  20. 	SListPopFront(&plist);
  21. 	SListPrint(plist);
  22. }
  23. void TestSList3()
  24. {
  25. 	STLNode* plist = NULL;//先让plist指向空
  26. 	SListPushBack(&plist, 1);
  27. 	SListPushBack(&plist, 2);
  28. 	//插入几个值,用节点存起来
  29. 	SListPushBack(&plist, 3);
  30. 	SListPushBack(&plist, 4);
  31. 	SListPrint(plist);
  32.  
  33. 	/*SListPopBack(&plist);
  34. 	SListPopBack(&plist);
  35. 	SListPrint(plist);*/
  36. 	//想在3的前面插入一个数字
  37. 	STLNode* pos = SListFind(plist, 1);
  38. 	if (pos)
  39. 	{
  40. 		SListInsert(&plist, pos, 10);
  41. 	}
  42. 	SListPrint(plist);
  43.  
  44. 	pos = SListFind(plist, 3);
  45. 	if (pos)
  46. 	{
  47. 		SListInsert(&plist, pos, 30);
  48. 	}
  49. 	SListPrint(plist);
  50. }
  51.  
  52. void TestSList4()
  53. {
  54. 	STLNode* plist = NULL;//先让plist指向空
  55. 	SListPushBack(&plist, 1);
  56. 	SListPushBack(&plist, 2);
  57. 	SListPushBack(&plist, 3);
  58. 	SListPushBack(&plist, 4);
  59. 	SListPrint(plist);
  60.  
  61. 	STLNode* pos = SListFind(plist, 3);
  62. 	if (pos)
  63. 	{
  64. 		SListErase(&plist, pos);
  65. 	}
  66. 	SListPrint(plist);
  67.  
  68. 	pos = SListFind(plist, 4);
  69. 	if (pos)
  70. 	{
  71. 		SListErase(&plist, pos);
  72. 	}
  73. 	SListPrint(plist);
  74. }
  75.  
  76. int main()
  77. {
  78. 	TestSList4();
  79.  
  80. 	return 0;
  81. }

今天就先到这了！！！

看到这里了还不给博主扣个：
⛳️ 点赞☀️收藏 ⭐️ 关注！

你们的点赞就是博主更新最大的动力！
有问题可以评论或者私信！！!

关注必回！！！

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

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

  

闽ICP备14008679号