• 数据结构——单链表

    fe594ea5bf754ddbb223a54d8fb1e7bc.gif

    目录

    一.前言

    二.链表表示和实现（单链表）

    1.1   顺序表的优缺点

    1.2   链表的概念及结构

     1.3   打印函数

    1.4   空间函数

    1.5   尾插函数（最最最麻烦的）

    1.5.1 尾插最关键部分！

    1.6   头插函数

    1.7   尾删函数 

    1.8   头删函数

    1.9   查找函数

    1.10 在pos之前插入x函数

    1.12 在pos之后插入x函数

    1.13 删除pos位置函数

    1.14 删除pos的后一个位置函数

    1.15 小测试

    三.全部代码 

    四.结语

    8fb442646f144d8daecdd2b61ec78ecd.png一.前言

    超级详细的单链表分析，把这一口吃下去妈妈再也不担心孩子因为知识匮乏饿肚子了~ 码字不易，希望大家多多支持我呀！（三连＋关注，你是我滴神！）

    二.链表表示和实现（单链表）

    1.1   顺序表的优缺点

    回顾前文所说的顺序表：

    缺点：

    • 头部和中部插入删除效率都不行  O(N)
    • 空间不够了，扩容有一定的消耗（尤其是异地扩容）
    • 扩容逻辑，可能还存在空间 （比如100满了，你要插入110个数据，扩容到200就会浪费90个空间）

    优点：

    • 尾插尾删足够快
    • 下标的随机访问和修改

    1.2   链表的概念及结构

    eb1c337966f243a18016cb3ca6d60898.png

    顺序表只需要知道首元素地址即可有一块连续的物理空间，并且尾部用size定义，而链表在物理空间并非连续，而是按需申请释放单个空间，空间之间用指针来相互联系。链表空间尾部是用NULL定义。

    c40ee35e82f7481db4e666f4909c6210.png

    备注：由malloc出来的节点地址是随机的。

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. //Test.c
    3. #include 
    4.  
    5. typedef int SLTDataType;
    6. typedef struct SListNode
    7. {
    8. 	SLTDataType data;
    9. 	struct SListNode* next;
    10. }SLTNode;
    11.  
    12.  
    13.  
    14. int main()
    15. {
    16. 	return 0;
    17. }

    从单链表的图示我们可以知道它是有多个节点链接而成的，一个节点里意味着有一个结构体，那么我们所指向节点的指针就应该是结构体指针变量。（struct SListNode* next)

     1.3   打印函数

    74804706e6644dbbb65b63042653e4e4.png

    因为phead是指向第一个节点的，所以不要轻易去改变，我们可以再创造一个指针来遍历链表。

    1. void PrintSList(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. }

    肯定许多友友无法理解为什么 cur = cur->next;这个next明明在代码中没有明确的指向，为什么还可以去使用呢？其实在cur指向第一个节点时cur->next是去取该结构体里面next的值，而next所存储的则是下一个结构体的地址。这样使得cur去指向第二个节点。至于为什么next能够存储下一个节点的地址就是关于编译器里的汇编该做（计算机会自动识别该指令）的事情了，我们就不做过多介绍了。

    接下来带大家感受一下简易链表的跑动情况；

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. //Test.c
    3. #include 
    4. #include 
    5.  
    6. typedef int SLTDataType;
    7. typedef struct SListNode
    8. {
    9. 	SLTDataType data;
    10. 	struct SListNode* next;
    11. }SLTNode;
    12.  
    13. void PrintSList(SLTNode* phead)
    14. {
    15. 	SLTNode* cur = phead;
    16. 	while (cur != NULL)
    17. 	{
    18. 		printf("%d->", cur->data);
    19. 		cur = cur->next;
    20. 	}
    21. 	printf("NULL\n");
    22. }
    23.  
    24. int main()
    25. {
    26. 	SLTNode* n1 = (SLTNode*)malloc(sizeof(SLTNode));
    27. 	//注意！这里malloc出来的节点是结构体，那么sizeof也得代入结构体的大小，
    28. 	//又因为是用结构体指针接收，所以强制类型转换也要使用(SLTNode*)。
    29. 	n1->data = 10;
    30. 	SLTNode* n2 = (SLTNode*)malloc(sizeof(SLTNode));
    31. 	n2->data = 20;
    32. 	SLTNode* n3 = (SLTNode*)malloc(sizeof(SLTNode));
    33. 	n3->data = 30;
    34.  
    35. 	n1->next = n2;
    36. 	n2->next = n3;
    37. 	n3->next = NULL;
    38.  
    39. 	PrintSList(n1);
    40. 	return 0;
    41. }

     b9ce52b2fffd4259b2389b000fa8a3ec.png

    在见识到简易链表后那接下来我们就要进入真正完整结构的链表了，老规矩，先创造3个文件。

    68c35c4132824d3d9e6057c0d1c5178f.png

    1.4   空间函数

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

    当我们创造空间函数后来进行测试：（不过会遇到一个难点，我们该如何把这些节点联系在一起呢？）

    0d864904eeb14d33bc041f8db690afda.png 这里我们提前先用头插来进行链接并且分析：

    6d596675ba7342f793548d96d1e120f5.png当我们的链表不为空时，要想头插需要用newnode这个新节点将plist与plist指向的第一个节点链接起来。先将第一个节点的地址（plist所指向）交给newnode这个新节点的next处，使新节点后面链接的是第一个节点，再把新节点的地址交给plist，使plist所指向的永远都是新的第一节点。

    注意！切不可交换顺序，如果先把新节点newnode的地址交给plist，那原先第一个节点就不能通过plist找到了，成为了野指针。

    当链表为空时，由于plist指向的是空指针，那么当插入新节点时，plist指向就变成了新节点（第一节点），而新节点所指向的就是空指针（newnode->next=NULL)。

    最后得出结论：关于头插的两句代码newnode->next = plist与plist = newnode完美契合两种情况，不需要用条件来区分开来。

     最终测试：

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. //Test.c
    3. #include "Slist.h"
    4. #include 
    5. #include 
    6.  
    7.  
    8. void TestSList1()
    9. {
    10. 	int n = 0;
    11. 	printf("请输入链表的长度：");
    12. 	scanf("%d", &n);
    13. 	printf("\n请依次输入每个节点的值：\n");
    14. 	SLTNode* plist = NULL;
    15. 	for (int i = 0; i < n; i++)
    16. 	{
    17. 		int val = 0;
    18. 		scanf("%d", &val);
    19. 		SLTNode* newnode = BuySlistNode(val);
    20. 		newnode->next = plist;
    21. 		plist = newnode;
    22. 		PrintSList(plist);
    23. 	}
    24. 	
    25. }
    26.  
    27.  
    28. int main()
    29. {
    30. 	TestSList1();
    31. 	return 0;
    32. }

    048f53ac7d7745578a8f92ebc81ab15a.png

    1.5   尾插函数（最最最麻烦的）

    尾插：肯定是从最后开始插入，malloc一个新空间，那么它所在节点先存储所插入的数，再然后就是空指针的地址。

    不过既然从最后插入，那得在原有数据上找到尾巴，从尾巴后面开始插入成为末尾。

    很多友友都会将代码误写成下面这样：（其实这样是大错特错的）

    482957a8c3514205947372dee553a042.png

    068119568fad4f96b6d4d87720a09962.png当我们画好物理图来分析就知道了，假如我们创造了新节点，而tail因为指向空指针而停止循环，但在我们执行最后一句代码后：tail = newnode，tail确实指向了新的节点，但是我们可以从图中看到新节点并没有和上一个节点链接起来！上一个节点所指向的仍然是空指针。

    1d50ae2e899f4b0c8a4f7cf5236af055.png

    该函数里有三个局部变量：phead, newnode, tail.出了作用域全部销毁。数据4并没有尾插进去，新开的这个节点反而丢失了。之所以4所在节点不会被销毁是因为该节点是malloc在堆上开辟的，除非你去free掉，否则是不会销毁的。这就是我们为什么费劲去malloc一个节点，如果单单在函数内部搞节点出了作用域就会被销毁。

    另外不用担心phead的销毁而找不到链表，phead是形参，我们外面还有pilst（实参）也有指向。

    最后我们再来测试是否插入：（尾插1000）

    1. //尾插函数
    2. void SLTPushBack(SLTNode* phead, SLTDataType x)
    3. {
    4. 	SLTNode* newnode = BuySlistNode(x);
    5. 	SLTNode* tail = phead;
    6. 	while (tail->next != NULL)
    7. 	{
    8. 		tail = tail->next;
    9. 	}
    10. 	tail->next = newnode;
    11. }
    1. void TestSList1()
    2. {
    3. 	int n = 0;
    4. 	printf("请输入链表的长度：");
    5. 	scanf("%d", &n);
    6. 	printf("\n请依次输入每个节点的值：\n");
    7. 	SLTNode* plist = NULL;
    8. 	for (int i = 0; i < n; i++)
    9. 	{
    10. 		int val = 0;
    11. 		scanf("%d", &val);
    12. 		SLTNode* newnode = BuySlistNode(val);
    13. 		newnode->next = plist;
    14. 		plist = newnode;
    15. 		PrintSList(plist);
    16. 	}
    17. 	SLTPushBack(plist, 1000);
    18. 	PrintSList(plist);
    19. 	
    20. }

    dd3ef00a801640b893a19de6d5dcdb04.png

    1.5.1 尾插最关键部分！

    前面是通过各种方式先折腾出一个链表，然后再进行尾插。

    现在我们来测试一下没有链表（空链表），没有节点的时候尾插会发生什么。

    1. //修改后的尾插函数
    2. void SLTPushBack(SLTNode* phead, SLTDataType x)
    3. {
    4. 	SLTNode* newnode = BuySlistNode(x);
    5. 	
    6. 	if (phead == NULL)
    7. 	{
    8. 		phead = newnode;
    9. 	}
    10. 	else
    11. 	{
    12. 		SLTNode* tail = phead;
    13. 		while (tail->next != NULL)
    14. 		{
    15. 			tail = tail->next;
    16. 		}
    17. 		tail->next = newnode;
    18. 	}
    19. }

    34dea38481b94df983cc20d9617fb3f2.png

    51186dfa351b467e9cd41eba296809bb.png 结果插入失败，这又是为什么呢？

    我们来一起分析一波：

    f6c627c881c1401cae71a1374564ba2c.png

    当if条件执行完后离开作用域phead和newnode变量跟之前一样销毁。

    ecde27c8fe8a477085eff53c5019c38f.png

    这时候跟前面测试已经不同！测试1中是已经有了链表，在外面作为实参的plist已经是指向了第一个节点，在只进行尾插的情况下plist会一直指向第一节点，所以反而不用在意出了局部作用域就销毁的phead。在测试1中phead的作用更多是让tail能顺利指向首节点，而不是去尝试改变plist的值。

    而现在的测试2中链表是空的，这意味着外面的plist的指向一直是空指针，需要phead来传递新节点的地址让外面的plist能够顺利指向它。可是phead只要离开作用域就会被销毁，无法起到传递地址的作用，这该怎么办呢？

    其实，这里的形参phead和实参plist本质上还是传值调用，phead只是plist的一份临时拷贝，改变phead的值是起不到改变plist的目的的，可它们不都是指针吗？怎么会改变不了呢？接下来，我为大家来演示一个小案例就明白了~

    小案例：

    1. void Swap1(int* p1, int* p2)
    2. {
    3. 	int tmp = *p1;
    4. 	*p1 = *p2;
    5. 	*p2 = tmp;
    6. }
    7.  
    8. void Swap2(int** pp1, int** pp2)
    9. {
    10. 	int* tmp = **pp1;
    11. 	**pp1 = **pp2;
    12. 	**pp2 = tmp;
    13. }
    14.  
    15. int main()
    16. {
    17. 	TestSList1();
    18. 	int a = 0;
    19. 	int b = 1;
    20. 	Swap1(&a, &b);
    21. 	int* x1 = &a;
    22. 	int* x2 = &b;
    23. 	Swap1(x1, x2);
    24. 	return 0;
    25. }

    在上述代码中，如果需要改变int的值，那就得传int*去接收。万一要改变的值是int*呢？那就得用int**去接收。我们在空链表的时候就相当于是传递x1,x2两个int*类型的值，但却用int*去接收，那x1,x2怎么可能会改变呢~

    所以要想让外面的plist能够改变，首先先传递plist的地址，再用二级指针去接收~

    1. void TestSList2()
    2. {
    3. 	SLTNode* plist = NULL;
    4. 	SLTPushBack(&plist, 1);
    5. 	SLTPushBack(&plist, 2);
    6. 	SLTPushBack(&plist, 3);
    7. 	SLTPushBack(&plist, 4);
    8. 	SLTPushBack(&plist, 5);
    9. 	PrintSList(plist);
    10. }
    11.  
    12. int main()
    13. {
    14. 	//TestSList1();
    15. 	TestSList2();
    16. 	//int a = 0;
    17. 	//int b = 1;
    18. 	//Swap1(&a, &b);
    19. 	//int* x1 = &a;
    20. 	//int* x2 = &b;
    21. 	//Swap1(x1, x2);
    22. 	return 0;
    23. }
    1. //修改后的尾插函数
    2. void SLTPushBack(SLTNode** pphead, SLTDataType x)
    3. {
    4. 	SLTNode* newnode = BuySlistNode(x);
    5. 	
    6. 	if (*pphead == NULL)
    7. 	{
    8.         //改变结构体的指针，用二级指针改变
    9. 		*pphead = newnode;
    10. 	}
    11. 	else
    12. 	{
    13. 		SLTNode* tail = *pphead;
    14. 		while (tail->next != NULL)
    15. 		{
    16. 			tail = tail->next;
    17. 		}
    18.         //改变结构体（next)，用结构体指针（tail)
    19. 		tail->next = newnode;
    20. 	}
    21. }

    c1ca8e41e2344ab0afe480619ee3c19f.png

    现在情况发生改变，我们的pphead是指向plist,而*pphead变成了去解引用地址，就是去看plist里面的所存储的地址，解引用发现plist里面存储的地址为空，那就把newnode的地址传递进去，达到传址调用的目的。c851911bb4ed49c4bc2e4001c67ebf36.png

    那为什么tail不用二级指针呢？，首先tail（结构体指针）指向的是一个结构体，tail->next是结构体里面的成员，而我们要想对结构体进行改变，用结构体指针就可以了。

    最费劲的地方结束啦，相信后面的内容大家肯定可以轻松掌握~

    1.6   头插函数

    在经历复杂的尾插函数洗礼后，那头插函数还需要二级指针吗？

    肯定需要啊，尾插只是在空链表时有必要用二级指针，那头插可就次次都需要二级指针了。

    尾插需要判断链表是否为空，因为一方是改变结构体，另一方是改变结构体指针。而头插就不用去判断链表是否为空了，反正都是去改变结构体指针。

     de98f8d113814b8aa0cd3699e53b172e.png

    1. //头插函数
    2. void SLTPushFront(SLTNode** pphead, SLTDataType x)
    3. {
    4.     assert(pphead);
    5. 	SLTNode* newnode = BuySlistNode(x);
    6. 	newnode->next = *pphead;
    7. 	*pphead = newnode;
    8. }

     测试一下：

    1. void TestSList2()
    2. {
    3. 	SLTNode* plist = NULL;
    4. 	SLTPushBack(&plist, 1);
    5. 	SLTPushBack(&plist, 2);
    6. 	SLTPushBack(&plist, 3);
    7. 	SLTPushBack(&plist, 4);
    8. 	SLTPushBack(&plist, 5);
    9. 	PrintSList(plist);
    10. 	SLTPushFront(&plist, 10);
    11. 	SLTPushFront(&plist, 20);
    12. 	SLTPushFront(&plist, 30);
    13. 	SLTPushFront(&plist, 40);
    14. 	PrintSList(plist);
    15. }

     a10d6e3c35c64fc5884941c038d33fbc.png

    1.7   尾删函数 

    如题：尾删需要二级指针吗？

    d08f29507dc74fcebb6be28aa839c566.png

    前面确实只需要注意改结构体就行了，不需要用到二级指针~，但单我们删到只剩下最后一个节点时，没有前一个节点置空，所以是需要改变plist让它指向NULL滴~所以还是需要用到二级指针哦。

    哈哈有没有发现只要把二级指针这一口吃下去了，后面都好说了~神挡杀神，佛挡杀佛~

    如果free掉最后的空间节点，那么它的前一个节点由于所存地址的空间已经丢失，那么所存储该地址的指针就会变成野指针。所以我们需要把在尾部前面的节点所存储的地址变成空指针，确保它是尾部删除后成为新的尾部。

    f9beca57ddd441db9d955e3ee8401e9c.png

    1. //尾删函数
    2. void SLTPopBack(SLTNode** pphead)
    3. {
    4.     assert(pphead);
    5.     //这里断言的目的是因为pphead指向的是plist的地址，而plist永远有所指向
    6.     //要么指向NULL，要么指向链表，所以pphead是不能为空的。
    7. 	//空
    8. 	assert(*pphead);
    9. 	//一个节点
    10. 	if ((*pphead)->next == NULL)
    11. 	{
    12. 		free(*pphead);
    13. 		*pphead = NULL;
    14. 	}
    15. 	//一个节点以上
    16. 	else
    17. 	{
    18. 		SLTNode* tailpre = NULL;
    19. 		SLTNode* tail = *pphead;
    20. 		while (tail->next != NULL)
    21. 		{
    22. 			tailpre = tail;
    23. 			tail = tail->next;
    24. 		}
    25. 		free(tail);
    26. 		tailpre->next = NULL;
    27. 	}
    28. }

    也有一种难看懂的写法：自行选择~

    1. //尾删函数
    2. void SLTPopBack(SLTNode** pphead)
    3. {
    4. 	//空
    5. 	assert(*pphead);
    6. 	//一个节点
    7. 	if ((*pphead)->next == NULL)
    8. 	{
    9. 		free(*pphead);
    10. 		*pphead = NULL;
    11. 	}
    12. 	//一个节点以上
    13. 	else
    14. 	{
    15. 		SLTNode* tail = *pphead;
    16. 		while (tail->next->next)
    17. 		{
    18.  
    19. 			tail = tail->next;
    20. 		}
    21. 		free(tail->next);
    22. 		tail->next = NULL;
    23. 	}
    24. 	
    25. 	
    26. 		
    27. 	
    28. }

    老规矩测试一下：

    1. void TestSList3()
    2. {
    3. 	SLTNode* plist = NULL;
    4. 	SLTPushBack(&plist, 1);
    5. 	SLTPushBack(&plist, 2);
    6. 	SLTPushBack(&plist, 3);
    7. 	SLTPushBack(&plist, 4);
    8. 	SLTPushBack(&plist, 5);
    9. 	PrintSList(plist);
    10.  
    11. 	SLTPopBack(&plist);
    12. 	PrintSList(plist);
    13.  
    14. 	SLTPopBack(&plist);
    15. 	PrintSList(plist);
    16.  
    17.  
    18. }

    251ab3f8c4bf46c8b09e975f520e83c5.png

    1.8   头删函数

    基本逻辑就是保存好下一节点newhead,然后再free掉首个节点，最后让plist指向newhead.

    b5097b5582eb4c7cbcd91a40fcf5a098.png

    1. //头删函数
    2. void SLTPopFront(SLTNode** pphead)
    3. {
    4.     assert(pphead);
    5. 	//空
    6. 	assert(*pphead);
    7. 	//非空
    8. 	SLTNode* newhead = (*pphead)->next;
    9. 	free(*pphead);
    10. 	*pphead = newhead;
    11. 	
    12. }

    测试一下：

    1. void TestSList4()
    2. {
    3. 	SLTNode* plist = NULL;
    4. 	SLTPushBack(&plist, 1);
    5. 	SLTPushBack(&plist, 2);
    6. 	SLTPushBack(&plist, 3);
    7. 	SLTPushBack(&plist, 4);
    8. 	SLTPushBack(&plist, 5);
    9. 	PrintSList(plist);
    10.  
    11. 	SLTPopFront(&plist);
    12. 	PrintSList(plist);
    13.  
    14. 	SLTPopFront(&plist);
    15. 	PrintSList(plist);
    16.  
    17. 	SLTPopFront(&plist);
    18. 	PrintSList(plist);
    19.  
    20. }

    4576c4b139754bf2ad0cf54de791a026.png

    1.9   查找函数

    20c2ab31baa5491a9aa0df559c3f5a90.png

    1. //查找函数
    2. SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
    3. {
    4. 	SLTNode* cur = phead;
    5. 	while (cur)
    6. 	{
    7. 		if (cur->data == x)
    8. 		{
    9. 			return cur;
    10. 		}
    11. 		cur = cur->next;
    12. 	}
    13. 	return NULL;
    14. }

    6f52d3d6123441d5a472cc7dc2864594.png

    查找函数也可以起到修改数值的作用

    1.10 在pos之前插入x函数

    首先暴力断言，避免链表为空的情况。其次，当我们想要在链表的首个节点之前插入时，可以用到头插函数的复用。那么这时候需要往头插函数里面传递什么呢？由图可知我们最终头插要修改的是plist的指向，所以需要把plist的地址给传过去，而pphead恰好指向plist的地址，所以这里可以传pphead。

    5a8afcab2c1d48638acf2891f1af0759.png

    a6ca7ba3398f48dab467b79705dfa347.png

    至于在其他位置插入我们只能找到pos之前的指针了~ 

    我们这里只需要注意让删除节点的前后节点相连就行了。其实这里和指定插入是一样的操作都是通过prev和pos来进行连接。后面就随便改就行了，这里反而不用在意顺序。

    03a53afe9b5d4de99c3fed130863dba2.png

    1. //在pos之前插入x
    2. void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
    3. {
    4.     assert(pphead);
    5. 	assert(pos);
    6. 	if (pos == *pphead)
    7. 	{
    8. 		SLTPushFront(pphead, x);
    9. 	}
    10. 	else
    11. 	{
    12. 		SLTNode* prev = *pphead;
    13. 		while (prev->next != pos)
    14. 		{
    15. 			prev = prev->next;
    16. 		}
    17. 		SLTNode* newnode = BuySlistNode(x);
    18. 		prev->next = newnode;
    19. 		newnode->next = pos;
    20. 	}
    21.  
    22. }

    测试一下：

    1. void TestSList5()
    2. {
    3. 	SLTNode* plist = NULL;
    4. 	SLTPushBack(&plist, 1);
    5. 	SLTPushBack(&plist, 2);
    6. 	SLTPushBack(&plist, 3);
    7. 	SLTPushBack(&plist, 4);
    8. 	SLTPushBack(&plist, 5);
    9. 	PrintSList(plist);
    10. 	int x = 0;
    11. 	scanf("%d", &x);
    12. 	SLTNode* pos = SLTFind(plist, x);
    13. 	if (pos)
    14. 	{
    15. 		SLTInsert(&plist, pos, 40);
    16. 	}
    17. 	PrintSList(plist);
    18.  
    19. }

    0547c49f978647ddb37b828512515101.png

    1.12 在pos之后插入x函数

    由于该函数不可能实现头插（不可能改变plist），所以就不用传递头指针给该函数接收了。

    b400c29ab3304972af2570670f4f3c6b.png

    该函数只需要注意一点，不要先在pos—>next存入newnode的地址，这样会丢失原本d3的地址，导致newnode—>next指向自己造成死循环。

    1. //在pos之后插入x
    2. void SLTInsertAfter(SLTNode* pos, SLTDataType x)
    3. {
    4. 	assert(pos);
    5. 	SLTNode* newnode = BuySlistNode(x);
    6. 	newnode->next = pos->next;
    7. 	pos->next = newnode;
    8.  
    9. }

    测试一下：

    1. void TestSList6()
    2. {
    3. 	SLTNode* plist = NULL;
    4. 	SLTPushBack(&plist, 1);
    5. 	SLTPushBack(&plist, 2);
    6. 	SLTPushBack(&plist, 3);
    7. 	SLTPushBack(&plist, 4);
    8. 	SLTPushBack(&plist, 5);
    9. 	PrintSList(plist);
    10. 	int x = 0;
    11. 	scanf("%d", &x);
    12. 	SLTNode* pos = SLTFind(plist, x);
    13. 	if (pos)
    14. 	{
    15. 		SLTInsertAfter(pos, 3);
    16. 	}
    17. 	PrintSList(plist);
    18.  
    19. }

    7811dd1c46314dd5ae7e09bc074c6a8f.png

    1.13 删除pos位置函数

    该函数有两点需要注意：

    • 需要记录pos之前的指针
    • 头删需要单独处理，直接复用头删函数（这时候就需要接收plist来改变它的指向了）

    82fa6a04455e40b9876200be89deba82.png

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

    测试一下:

    1. void TestSList7()
    2. {
    3. 	SLTNode* plist = NULL;
    4. 	SLTPushBack(&plist, 1);
    5. 	SLTPushBack(&plist, 2);
    6. 	SLTPushBack(&plist, 3);
    7. 	SLTPushBack(&plist, 4);
    8. 	SLTPushBack(&plist, 5);
    9. 	PrintSList(plist);
    10. 	int x = 0;
    11. 	scanf("%d", &x);
    12. 	SLTNode* pos = SLTFind(plist, x);
    13. 	if (pos)
    14. 	{
    15. 		SLTErase(&plist,pos);
    16.         pos = NULL;
    17.         //用完pos记得置空，不然它还是会一直指向原位置
    18. 	}
    19. 	PrintSList(plist);
    20.  
    21. }

    ab4a518dadcd4ea8b1da5930bb97efd8.png

    1.14 删除pos的后一个位置函数

    8c511a23707b46859a585420f76009c4.png

    1. //删除pos的后一个位置
    2. void SLTInsertErase(SLTNode* pos)
    3. {
    4. 	assert(pos);
    5. 	assert(pos->next);//如果pos指向尾节点，那是没有意义的
    6. 	SLTNode* posNext = pos->next;
    7. 	pos->next = posNext->next;
    8. 	free(posNext);
    9. }

    测试一下：

    1.  
    2. void TestSList8()
    3. {
    4. 	SLTNode* plist = NULL;
    5. 	SLTPushBack(&plist, 1);
    6. 	SLTPushBack(&plist, 2);
    7. 	SLTPushBack(&plist, 3);
    8. 	SLTPushBack(&plist, 4);
    9. 	SLTPushBack(&plist, 5);
    10. 	PrintSList(plist);
    11. 	int x = 0;
    12. 	scanf("%d", &x);
    13. 	SLTNode* pos = SLTFind(plist, x);
    14. 	if (pos)
    15. 	{
    16. 		SLTEraseAfter(pos);
    17. 		pos = NULL;
    18. 	}
    19. 	PrintSList(plist);
    20.  
    21. }

    634c822aa23c4d97b1b179770dd80b97.png

    1.15 小测试

    9a85beb8e62840a59e1f7441d81127f9.png

    如图所示，在不给头指针的情况下我们是没办法找到pos前面的指针的，这样起不到链接pos后面节点的作用。

     8f13a8080fb441dc991682f47bd5778c.png

    我们可以把d2的值给到前面的d1，然后让pos->next指向d2地址后面节点的地址，再free掉d2就好了，不过这样有一个缺陷，就是当pos指向尾节点时，后面没有值可以跟它换。

    三.全部代码 

    1. #pragma once
    2. //Slist.h
    3. #include 
    4. #include 
    5. #include 
    6.  
    7. typedef int SLTDataType;
    8. typedef struct SListNode
    9. {
    10. 	SLTDataType data;
    11. 	struct SListNode* next;
    12. }SLTNode;
    13.  
    14.  
    15. //打印函数
    16. void PrintSList(SLTNode* phead);
    17.  
    18. //空间函数
    19. SLTNode* BuySlistNode(SLTDataType x);
    20.  
    21. //尾插函数
    22. void  SLTPushBack(SLTNode** pphead, SLTDataType x);
    23.  
    24. //头插函数
    25. void  SLTPushFront(SLTNode** pphead, SLTDataType x);
    26.  
    27. //尾删函数
    28. void  SLTPopBack(SLTNode** pphead);
    29.  
    30. //头删函数
    31. void  SLTPopFront(SLTNode** pphead);
    32.  
    33. //查找函数
    34. SLTNode* SLTFind(SLTNode* phead, SLTDataType x);
    35.  
    36. //在pos之前插入x
    37. void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
    38.  
    39. //在pos之后插入x
    40. void SLTInsertAfter(SLTNode* pos, SLTDataType x);
    41.  
    42. //删除pos位置
    43. void SLTErase(SLTNode** pphead, SLTNode* pos);
    44.  
    45. //删除pos的后一个位置
    46. void SLTEraseAfter(SLTNode* pos);

    ———————————————————————————————————————————

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. //Slist.c
    3. #include "Slist.h"
    4.  
    5. //打印函数
    6. void PrintSList(SLTNode* phead)
    7. {
    8. 	SLTNode* cur = phead;
    9. 	while (cur != NULL)
    10. 	{
    11. 		printf("%d->", cur->data);
    12. 		cur = cur->next;
    13. 	}
    14. 	printf("NULL\n");
    15. }
    16.  
    17. //空间函数
    18. SLTNode* BuySlistNode(SLTDataType x)
    19. {
    20. 	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
    21. 	if (newnode == NULL)
    22. 	{
    23. 		perror("malloc fail");
    24. 		exit(-1);
    25. 	}
    26. 	newnode->data = x;
    27. 	newnode->next = NULL;
    28. 	return newnode;
    29.  
    30. }
    31.  
    32. 尾插函数
    33. //SLTNode* SLTPushBack(SLTNode* phead, SLTDataType x)
    34. //{
    35. //	SLTNode* newnode = BuySlistNode(x);
    36. //	SLTNode* tail = phead;
    37. //	while (tail->next != NULL)
    38. //	{
    39. //		tail = tail->next;
    40. //	}
    41. //	tail->next = newnode;
    42. //}
    43.  
    44. //修改后的尾插函数
    45. void SLTPushBack(SLTNode** pphead, SLTDataType x)
    46. {
    47. 	SLTNode* newnode = BuySlistNode(x);
    48.  
    49. 	if (*pphead == NULL)
    50. 	{
    51. 		*pphead = newnode;
    52. 	}
    53. 	else
    54. 	{
    55. 		SLTNode* tail = *pphead;
    56. 		while (tail->next != NULL)
    57. 		{
    58. 			tail = tail->next;
    59. 		}
    60. 		tail->next = newnode;
    61. 	}
    62. }
    63.  
    64. //头插函数
    65. void SLTPushFront(SLTNode** pphead, SLTDataType x)
    66. {
    67. 	assert(pphead);
    68. 	SLTNode* newnode = BuySlistNode(x);
    69. 	newnode->next = *pphead;
    70. 	*pphead = newnode;
    71. }
    72.  
    73. //尾删函数
    74. void SLTPopBack(SLTNode** pphead)
    75. {
    76. 	assert(pphead);
    77. 		//这里断言的目的是因为pphead指向的是plist的地址，而plist永远有所指向
    78. 		//要么指向NULL，要么指向链表，所以pphead是不能为空的。
    79. 	//空
    80. 	assert(*pphead);
    81. 	//一个节点
    82. 	if ((*pphead)->next == NULL)
    83. 	{
    84. 		free(*pphead);
    85. 		*pphead = NULL;
    86. 	}
    87. 	//一个节点以上
    88. 	else
    89. 	{
    90. 		SLTNode* tailpre = NULL;
    91. 		SLTNode* tail = *pphead;
    92. 		while (tail->next != NULL)
    93. 		{
    94. 			tailpre = tail;
    95. 			tail = tail->next;
    96. 		}
    97. 		free(tail);
    98. 		tailpre->next = NULL;
    99. 	}
    100. }
    101.  
    102. 尾删函数
    103. //SLTNode* SLTPopBack(SLTNode** pphead)
    104. //{
    105. //	//空
    106. //	assert(*pphead);
    107. //	//一个节点
    108. //	if ((*pphead)->next != NULL)
    109. //	{
    110. //		free(*pphead);
    111. //		*pphead = NULL;
    112. //	}
    113. //	//一个节点以上
    114. //	else
    115. //	{
    116. //		SLTNode* tail = *pphead;
    117. //		while (tail->next->next)
    118. //		{
    119. //
    120. //			tail = tail->next;
    121. //		}
    122. //		free(tail->next);
    123. //		tail->next = NULL;
    124. //	}
    125. //	
    126.  
    127.  
    128. //头删函数
    129. void  SLTPopFront(SLTNode** pphead)
    130. {
    131. 	assert(pphead);
    132. 	//空
    133. 	assert(*pphead);
    134. 	//非空
    135. 	SLTNode* newhead = (*pphead)->next;
    136. 	free(*pphead);
    137. 	*pphead = newhead;
    138.  
    139. }
    140.  
    141. //查找函数
    142. SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
    143. {
    144. 	SLTNode* cur = phead;
    145. 	while (cur)
    146. 	{
    147. 		if (cur->data == x)
    148. 		{
    149. 			return cur;
    150. 		}
    151. 		cur = cur->next;
    152. 	}
    153. 	return NULL;
    154. }
    155.  
    156. //在pos之前插入x
    157. void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
    158. {
    159. 	assert(pphead);
    160. 	assert(pos);
    161. 	if (pos == *pphead)
    162. 	{
    163. 		SLTPushFront(pphead, x);
    164. 	}
    165. 	else
    166. 	{
    167. 		SLTNode* prev = *pphead;
    168. 		while (prev->next != pos)
    169. 		{
    170. 			prev = prev->next;
    171. 		}
    172. 		SLTNode* newnode = BuySlistNode(x);
    173. 		prev->next = newnode;
    174. 		newnode->next = pos;
    175. 	}
    176.  
    177. }
    178.  
    179. 在pos之后删除x
    180. //void SLTInsertAfter(SLTNode** pphead, SLTNode* pos, SLTDataType x)
    181. //{
    182. //	assert(pos);
    183. //	SLTNode* after = pos->next;
    184. //	while (after->data != x)
    185. //	{
    186. //		after = after->next;
    187. //	}
    188. //	pos->next = after->next;
    189. //	free(after);
    190. //	pos->next = after;
    191. //	
    192. //}
    193.  
    194. //在pos之后插入x
    195. void SLTInsertAfter(SLTNode* pos, SLTDataType x)
    196. {
    197. 	assert(pos);
    198. 	SLTNode* newnode = BuySlistNode(x);
    199. 	newnode->next = pos->next;
    200. 	pos->next = newnode;
    201.  
    202. }
    203.  
    204. //删除pos位置
    205. void SLTErase(SLTNode** pphead, SLTNode* pos)
    206. {
    207. 	assert(pphead);
    208. 	assert(pos);
    209. 	if (pos == *pphead)
    210. 	{
    211. 		SLTPopFront(pphead);
    212. 	}
    213. 	else
    214. 	{
    215. 		SLTNode* prev = *pphead;
    216. 		{
    217. 			while (prev->next != pos)
    218. 			{
    219. 				prev = prev->next;
    220. 			}
    221. 			prev->next = pos->next;
    222. 			free(pos);
    223. 		}
    224. 	}
    225. }
    226.  
    227. //删除pos的后一个位置
    228. void SLTEraseAfter(SLTNode* pos)
    229. {
    230. 	assert(pos);
    231. 	assert(pos->next);//如果pos指向尾节点，那是没有意义的
    232. 	SLTNode* posNext = pos->next;
    233. 	pos->next = posNext->next;
    234. 	free(posNext);
    235. }

    —————————————————————————————————————————— 

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. //Test.c
    3. #include "Slist.h"
    4. #include 
    5. #include 
    6.  
    7.  
    8. void TestSList1()
    9. {
    10. 	int n = 0;
    11. 	printf("请输入链表的长度：");
    12. 	scanf("%d", &n);
    13. 	printf("\n请依次输入每个节点的值：\n");
    14. 	SLTNode* plist = NULL;
    15. 	for (int i = 0; i < n; i++)
    16. 	{
    17. 		int val = 0;
    18. 		scanf("%d", &val);
    19. 		SLTNode* newnode = BuySlistNode(val);
    20. 		newnode->next = plist;
    21. 		plist = newnode;
    22. 		PrintSList(plist);
    23. 	}
    24. 	SLTPushBack(plist, 1000);
    25. 	PrintSList(plist);
    26. 	
    27. }
    28.  
    29. //void Swap1(int* p1, int* p2)
    30. //{
    31. //	int tmp = *p1;
    32. //	*p1 = *p2;
    33. //	*p2 = tmp;
    34. //}
    35. //
    36. //void Swap2(int** p1, int** p2)
    37. //{
    38. //	int* tmp = **p1;
    39. //	**p1 = **p2;
    40. //	**p2 = tmp;
    41. //}
    42.  
    43. void TestSList2()
    44. {
    45. 	SLTNode* plist = NULL;
    46. 	SLTPushBack(&plist, 1);
    47. 	SLTPushBack(&plist, 2);
    48. 	SLTPushBack(&plist, 3);
    49. 	SLTPushBack(&plist, 4);
    50. 	SLTPushBack(&plist, 5);
    51. 	PrintSList(plist);
    52. 	SLTPushFront(&plist, 10);
    53. 	SLTPushFront(&plist, 20);
    54. 	SLTPushFront(&plist, 30);
    55. 	SLTPushFront(&plist, 40);
    56. 	PrintSList(plist);
    57. }
    58. void TestSList3()
    59. {
    60. 	SLTNode* plist = NULL;
    61. 	SLTPushBack(&plist, 1);
    62. 	SLTPushBack(&plist, 2);
    63. 	SLTPushBack(&plist, 3);
    64. 	SLTPushBack(&plist, 4);
    65. 	SLTPushBack(&plist, 5);
    66. 	PrintSList(plist);
    67.  
    68. 	SLTPopBack(&plist);
    69. 	PrintSList(plist);
    70.  
    71. 	SLTPopBack(&plist);
    72. 	PrintSList(plist);
    73.  
    74.  
    75. }
    76. void TestSList4()
    77. {
    78. 	SLTNode* plist = NULL;
    79. 	SLTPushBack(&plist, 1);
    80. 	SLTPushBack(&plist, 2);
    81. 	SLTPushBack(&plist, 3);
    82. 	SLTPushBack(&plist, 4);
    83. 	SLTPushBack(&plist, 5);
    84. 	PrintSList(plist);
    85.  
    86. 	SLTPopFront(&plist);
    87. 	PrintSList(plist);
    88.  
    89. 	SLTPopFront(&plist);
    90. 	PrintSList(plist);
    91.  
    92. 	SLTPopFront(&plist);
    93. 	PrintSList(plist);
    94.  
    95. }
    96.  
    97. void TestSList5()
    98. {
    99. 	SLTNode* plist = NULL;
    100. 	SLTPushBack(&plist, 1);
    101. 	SLTPushBack(&plist, 2);
    102. 	SLTPushBack(&plist, 3);
    103. 	SLTPushBack(&plist, 4);
    104. 	SLTPushBack(&plist, 5);
    105. 	PrintSList(plist);
    106. 	int x = 0;
    107. 	scanf("%d", &x);
    108. 	SLTNode* pos = SLTFind(plist, x);
    109. 	if (pos)
    110. 	{
    111. 		SLTInsert(&plist, pos, 40);
    112. 	}
    113. 	PrintSList(plist);
    114.  
    115. }
    116.  
    117. void TestSList6()
    118. {
    119. 	SLTNode* plist = NULL;
    120. 	SLTPushBack(&plist, 1);
    121. 	SLTPushBack(&plist, 2);
    122. 	SLTPushBack(&plist, 3);
    123. 	SLTPushBack(&plist, 4);
    124. 	SLTPushBack(&plist, 5);
    125. 	PrintSList(plist);
    126. 	int x = 0;
    127. 	scanf("%d", &x);
    128. 	SLTNode* pos = SLTFind(plist, x);
    129. 	if (pos)
    130. 	{
    131. 		SLTInsertAfter(pos, 3);
    132. 	}
    133. 	PrintSList(plist);
    134.  
    135. }
    136. void TestSList7()
    137. {
    138. 	SLTNode* plist = NULL;
    139. 	SLTPushBack(&plist, 1);
    140. 	SLTPushBack(&plist, 2);
    141. 	SLTPushBack(&plist, 3);
    142. 	SLTPushBack(&plist, 4);
    143. 	SLTPushBack(&plist, 5);
    144. 	PrintSList(plist);
    145. 	int x = 0;
    146. 	scanf("%d", &x);
    147. 	SLTNode* pos = SLTFind(plist, x);
    148. 	if (pos)
    149. 	{
    150. 		SLTErase(&plist,pos);
    151. 		pos = NULL;
    152. 	}
    153. 	PrintSList(plist);
    154.  
    155. }
    156.  
    157.  
    158. void TestSList8()
    159. {
    160. 	SLTNode* plist = NULL;
    161. 	SLTPushBack(&plist, 1);
    162. 	SLTPushBack(&plist, 2);
    163. 	SLTPushBack(&plist, 3);
    164. 	SLTPushBack(&plist, 4);
    165. 	SLTPushBack(&plist, 5);
    166. 	PrintSList(plist);
    167. 	int x = 0;
    168. 	scanf("%d", &x);
    169. 	SLTNode* pos = SLTFind(plist, x);
    170. 	if (pos)
    171. 	{
    172. 		SLTEraseAfter(pos);
    173. 		pos = NULL;
    174. 	}
    175. 	PrintSList(plist);
    176.  
    177. }
    178.  
    179. int main()
    180. {
    181. 	//TestSList1();
    182. 	//TestSList2();
    183. 	TestSList8();
    184. 	//int a = 0;
    185. 	//int b = 1;
    186. 	//Swap1(&a, &b);
    187. 	//int* x1 = &a;
    188. 	//int* x2 = &b;
    189. 	//Swap1(x1, x2);
    190. 	return 0;
    191. }

    4b12323f94834afd9ec146a3c10df229.jpeg四.结语

    虽然单链表用起来挺矬的哈哈，但是我们平时的oj题大部分都是用单链表举例子，正是因为有自身缺陷才方便出题嘛~单链表也会对后面的哈希图理解起到辅助效果。最后感谢大家的观看，友友们能够学习到新的知识是额滴荣幸，期待我们下次相见~

  • 相关阅读:
    Days task Privacy Policy
    这几个颠覆性PyCharm插件你一定要知道
    Java面试题大全（整理版）1000+面试题附答案详解，最全面详细，看完稳了
    【第四篇】商城系统-品牌管理实现
    入门python
    深入浅出DAX：数据分析
    浙大版C语言题目集-函数题6
    Centos7 Yum安装PHP7.2
    Hadoop Hive介绍
    无需百度网盘SVIP提速不限速满速下载方法，2种方法都亲自实测有效
  • 原文地址：https://blog.csdn.net/fax_player/article/details/132634804