• DS线性表之链表

    前言

    我们上一期介绍了顺序表，它的底层就是数组，我们也分别对顺序表的动态版本和静态版本进行了实现！并且分析了顺序表的优缺点，优点是：尾插、尾删效率很高，其时间复杂度是O(1)；缺点是：在头部插入、删除的时候效率低，其时间复杂度是O(N);而且即使是动态版本的扩容也是会浪费空间的（这里在动态内存管理介绍realloc时专门介绍过）！！这个上期的最后也介绍了！我们想有没有一种数据结构，用一个添加一个，做到最起码的空间不浪费呢？答案是：有的~！他就是我们本期介绍的链表！

    本期内容介绍

    什么是链表

    链表的分类

    单链表的实现（不带头）

    单链表的实现（带头）

    带头双向循环链表的实现

    链表和顺序表的区别

    目录

    前言

    本期内容介绍

    一、什么是链表

    二、链表的分类

    三、单链表的实现（不带头）

    链表节点类型申明

    动态申请一个节点

    链表的打印

    链表的销毁

    单链表尾插

    单链表尾删

    单链表头插

    单链表头删

    单链表查找

    在pos前插入x

    在pos后插入x

    删除pos位置

    删除pos位置的下一个

    全部源码：

    四、单链表的实现（带头）

    链表结点类型声明

    链表初始化

    链表的销毁

    链表的打印

    动态开辟一个节点

    单链表尾插

    单链表的尾删

    单链表头插

    单链表的头删

    单链表查找

    单链表修改

    在pos前插入

    在pos后插入

    删除pos位置

    删除pos后一个

    链表的长度

    总结：

    全部源码：

    五、带头双向循环链表的实现

    结点类型声明

    初始化

    销毁

    打印

    动态开辟新节点

    尾插

    尾删

    头插

    头删 

    查找

    修改

    在pos前插入

    在pos后插入

    删除pos

    删除pos的下一个

    获取长度

    六、链表和顺序表的区别

    一、什么是链表

    链表是一种物理存储结构上非连续（非顺序存储的结构），逻辑结构上连续的一种存储数据的结构！它的逻辑连续是由他里面的指针实现的~！

    我们在结构体那一期介绍过一个东西叫结构体的自引用，他实质上就是链表的声明！OK，我们来个栗子回忆一下：

    1. struct Node
    2. {
    3. 	int data;
    4. 	struct Node* next;
    5. };

    这就是一个链表的申明，也就是结构体的自引用~！他这里一般把data叫做数据域，next叫做指针域！链表的指针域是指向下一个同类型的节点~！什么意思呢？我们再来画个图理解一下：

    这个图是不是很清楚的反映了上了上面的所有的点，物理结构非连续的（因为是malloc的节点在堆上，它的内存时操作系统随机分配的可能是连续的但大概率是不连续的），他们每个节点的地址都不连续，逻辑结构连续是因为当前节点的next存的是下一个节点的地址，这样只要第一个节点的地址就可以访问链表的所有节点了~！

    这就和火车一样一节连一节：

    二、链表的分类

    链表的结构有8种，是否带头节点，单双向，是否循环~的组合结果！

    在这里我们先介绍不带头的单链表，再介绍带头的单链表，最后在实现链表中最优秀的结构---》带头双向循环链表！这三种如果熟练掌握其他就都是小卡拉米~！OK，我们还是画一下，认识一下：

    不带头：

    带头：

    这就是链表的8种结构的图！其实常见的或常用的就两种无头单链表和双向循环链表！但单链表不会单独做什么存储工作，他会配合其他的去实现更高阶的数据结构例如就是实现哈希桶和图的邻接表等；

    而双向循环链表是会单独存储数据的，例如你每天刷的抖音是不是有访客呀~！它实际上底层就是双向循环链表，每次来一个方可头插一个，若一个人多次访问你的主页，也不过是改一下指针的事~！

    三、单链表的实现（不带头）

    OK，我们还是和往期一样采用多文件编程，申明等都放在.h文件里， 实现放在.c的文件， 测试在test.c中。

    一开始我们得先声明一下链表的每个节点的类型吧！

    链表节点类型申明

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

    动态申请一个节点

    这里由于是不带头的所以就不用初始化的，链表是1个或多个节点组成的，我们只要在申请的时候处理好它的next就OK！我们把next 一开始申请成功后置为NULL，这样即使是最后一个也不用单独处理为NULL了！

    1. //动态申请一个节点
    2. SListNode* BuySListNode(SLDataType x)
    3. {
    4. 	SListNode* newnode = (SListNode*)malloc (sizeof(SListNode));
    5. 	if (newnode == NULL)
    6. 	{
    7. 		perror("malloc failed");
    8. 		exit(-1);
    9. 	}
    10.  
    11. 	newnode->data = x;
    12. 	newnode->next = NULL;
    13.  
    14. 	return newnode;
    15. }

    链表的打印

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

    链表的销毁

    为了使程序的健壮性更高，以及防止程序出现内存泄漏，我们要在操作完链表后记得销毁~！

    这里从头开始，把每一个节点free即可，但这里由于是不带头的，所以得用二级指针！！！这里head本质是形参，改变形参不改变实参，要改变形参影响实参，我们得传实参的地址！

    最后free完了记得把头置空！否则就是野指针！

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

    单链表尾插

    这里我们先来个硬菜不带头节点的单链表的尾插！这里还是得用二级指针，因为一开始如果链表为空第一个插入的就得是头，head就得指向他，所以改变指针的指向要用二级指针。这里head是二级指针，即使外面的链表为空他也不可能为空，因此断言一下！然后新开一个节点，判断是否是第一个插入。如果是，直接让head指向他，否则找到尾节点后插入即可~！

    1. //尾插
    2. void SListPushBack(SListNode** head, SLDataType x)
    3. {
    4. 	assert(head);
    5. 	SListNode* node = BuySListNode(x);
    6. 	if (*head == NULL)
    7. 	{
    8. 		*head = node;
    9. 	}
    10. 	else
    11. 	{
    12. 		SListNode* cur = *head;
    13. 		while (cur->next)
    14. 		{
    15. 			cur = cur->next;
    16. 		}
    17. 		cur->next = node;
    18. 	}
    19.  
    20. }

    单链表尾删

    删除这里一开始想到的就是判断当前链表是否为空！如果为空了就不要删了，判断的方式还是和以前一样，“温柔型”和“暴力型”，小编就比较喜欢暴力型~！然后这里也要考虑删完的情况，也即是head的处理，如果把最后一个节点都删了就把head置为空,而这里的head是形参，要改变它得用它的指针也即是二级~！

    1. //尾删
    2. void SListPopBack(SListNode** head)
    3. {
    4. 	assert(head);
    5. 	assert(*head);//没有节点可删
    6.  
    7. 	if ((*head)->next == NULL)
    8. 	{
    9. 		free(*head);
    10. 		*head = NULL;
    11. 	}
    12. 	else
    13. 	{
    14. 		SListNode* cur = *head;
    15. 		while (cur->next->next)
    16. 		{
    17. 			cur = cur->next;
    18. 		}
    19. 		free(cur->next);
    20. 		cur->next = NULL;
    21. 	}
    22. }

    当然这里常规的删除还有一种写法，即快慢指针法：用个prv前驱指针记录它的前面的一个节点。当cur->next不等于NULL时把cur赋值给prv，当cur->next为空时free掉cur，prv->next 置空即可!

    1. //尾删
    2. void SListPopBack(SListNode** head)
    3. {
    4. 	assert(head);
    5. 	assert(*head);//没有节点可删
    6.  
    7. 	if ((*head)->next == NULL)
    8. 	{
    9. 		free(*head);
    10. 		*head = NULL;
    11. 	}
    12. 	else
    13. 	{
    14. 		/*SListNode* cur = *head;
    15. 		while (cur->next->next)
    16. 		{
    17. 			cur = cur->next;
    18. 		}
    19. 		free(cur->next);
    20. 		cur->next = NULL;*/
    21.  
    22. 		SListNode* cur = *head;
    23. 		SListNode* prv = NULL;
    24. 		while (cur->next)
    25. 		{
    26. 			prv = cur;
    27. 			cur = cur->next;
    28. 		}
    29. 		free(cur);
    30. 		prv->next = NULL;
    31. 	}
    32. }

    OK，我们还是养成好习惯写点测试一点：

    1. void testBack()
    2. {
    3. 	SListNode* s = NULL;//这里不置空就是野指针，会直接奔溃掉
    4. 	SListPushBack(&s, 1);
    5. 	SListPushBack(&s, 2);
    6. 	SListPushBack(&s, 3);
    7. 	SListPushBack(&s, 4);
    8. 	SListPushBack(&s, 5);
    9. 	SListPrint(s);
    10.  
    11. 	SListPopBack(&s);
    12. 	SListPrint(s);
    13.  
    14. 	SListPopBack(&s);
    15. 	SListPrint(s);
    16. 	SListPopBack(&s);
    17. 	SListPrint(s);
    18. 	SListPopBack(&s);
    19. 	SListPrint(s);
    20.  
    21. 	SListPopBack(&s);
    22. 	SListPrint(s);
    23. 	//SListPopBack(&s);//测试尾删是否有Bug
    24. 	//SListPrint(s);
    25.  
    26. 	SListDestory(&s);
    27. }

    OK，尾插尾删没有问题！我们下来在来搞一下头插头删！

    单链表头插

    头插相对简单，新开的节点next连接head在让head指向新节点。但是还时要注意，一开始为空链表的情况，所以得用二级指针搞~！

    1. //头插
    2. void SListPushFront(SListNode** head, SLDataType x)
    3. {
    4. 	assert(head);
    5. 	SListNode* node = BuySListNode(x);
    6. 	if (*head == NULL)
    7. 	{
    8. 		*head = node;
    9. 	}
    10. 	else
    11. 	{
    12. 		node->next = *head;
    13. 		*head = node;
    14. 	}
    15. }

    单链表头删

    这里删除首先要注意为空的情况，其次只有一个节点的情况，删掉这一个节点把head置空，这里也要改变head的值所以要用二级指针。正常删除就是保存当前节点的下一个节点，free当前节点在把刚保存的下一个节点赋值给当前节点~！

    1. //头删
    2. void SListPopFront(SListNode** head)
    3. {
    4. 	assert(head);
    5. 	assert(*head);//没有节点可删
    6.  
    7. 	if ((*head)->next == NULL)
    8. 	{
    9. 		free(*head);
    10. 		*head = NULL;
    11. 	}
    12. 	else
    13. 	{
    14. 		SListNode* tail = (*head)->next;
    15. 		free(*head);
    16. 		*head = tail;
    17. 	}
    18. }

    OK，还是来测试一下：

    1. void testFront()
    2. {
    3. 	SListNode* s = NULL;
    4. 	SListPushFront(&s, 1);
    5. 	SListPushFront(&s, 2);
    6. 	SListPushFront(&s, 3);
    7. 	SListPushFront(&s, 4);
    8. 	SListPushFront(&s, 5);
    9. 	SListPrint(s);
    10.  
    11. 	SListPopFront(&s);
    12. 	SListPrint(s);
    13. 	SListPopFront(&s);
    14. 	SListPrint(s);
    15. 	SListPopFront(&s);
    16. 	SListPrint(s);
    17. 	SListPopFront(&s);
    18. 	SListPrint(s);
    19. 	SListPopFront(&s);
    20. 	SListPrint(s);
    21. 	//SListPopFront(&s);//测试头删是是否有Bug
    22. 	//SListPrint(s);
    23.  
    24. 	SListDestory(&s);
    25. }

    OK，没有问题，我们在来实现一下查找和在pos前插入和pos后插入！

    单链表查找

    这里就很简单了，找到了返回该节点的地址，否则返回NULL即可！这里仅仅是查找不改变内容所以一级指针即可！

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

    在pos前插入x

    这里是在pos位置前插入一个x，有两种写法。这里也得注意第一个插入的情况！所以得用二级指针！第一种是直接手动实现没有借助一点外力，第二种调用了头插解决第一次插入的情况~！而且注意的是第一种你必须加break插入后跳出否则就是死循环，第二种改变不用担心这种情况~！

    1. //在pos位置前插入
    2. void SListInsert(SListNode** head, SListNode* pos, SLDataType x)
    3. {
    4. 	assert(head);
    5. 	assert(pos);
    6.  
    7. 	SListNode* node = BuySListNode(x);
    8. 	if (*head == NULL)
    9. 	{
    10. 		node->next = *head;
    11. 		*head = node;
    12. 	}
    13. 	else
    14. 	{
    15. 		SListNode* cur = *head;
    16. 		while (cur)
    17. 		{
    18. 			if (cur->next == pos)
    19. 			{
    20. 				node->next = pos;
    21. 				cur->next = node;
    22. 				break;
    23. 			}
    24. 			cur = cur->next;
    25. 		}
    26. 	}
    27.  
    28. }
    1. //在pos位置前插入
    2. void SListInsert(SListNode** head, SListNode* pos, SLDataType x)
    3. {
    4. 	assert(head);
    5. 	assert(pos);
    6.  
    7. 	if (*head == NULL)
    8. 	{
    9. 		SListPushFront(head, x);
    10. 	}
    11. 	else
    12. 	{
    13. 		SListNode* cur = *head;
    14. 		while (cur->next != pos)
    15. 		{
    16. 			cur = cur->next;
    17. 		}
    18.  
    19. 		SListNode* node = BuySListNode(x);
    20. 		node->next = pos;
    21. 		cur->next = node;
    22. 	}
    23.  
    24. }

    在pos后插入x

    这个接口就更简单了，只需要让pos->next 连接到node->next然后再让pos->next 链接上node即可~！也不用担心pos->next 为空的情况！

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

    OK，还是来测试一下：

    1. testInsert()
    2. {
    3. 	SListNode* s = NULL;
    4. 	SListPushFront(&s, 1);
    5. 	SListPushFront(&s, 2);
    6. 	SListPushFront(&s, 3);
    7. 	SListPushFront(&s, 4);
    8. 	SListPushFront(&s, 5);
    9. 	SListPrint(s);
    10.  
    11. 	SListInsert(&s, SListFind(s, 1), 10);
    12. 	SListPrint(s);
    13. 	SListInsert(&s, SListFind(s, 1), 100);
    14. 	SListPrint(s);
    15.  
    16. 	SListInsertAfter(SListFind(s, 4), 40);
    17. 	SListPrint(s);
    18. 	SListDestory(&s);
    19. }

    OK，没有问题，我们在来实现一下删除pos位置和删除pos位置的后一个节点~！

    删除pos位置

    这个接口就是当头和pos相同时，可以直接调用头删不用自己多判断。否则就遍历找pos然后删除~~！

    1. //删除pos位置
    2. void SListErase(SListNode** head, SListNode* pos)
    3. {
    4. 	assert(head);
    5. 	assert(*head);//空了就不要删了
    6. 	assert(pos);
    7.  
    8. 	if (*head == pos)
    9. 	{
    10. 		SListPopFront(head);
    11. 	}
    12. 	else
    13. 	{
    14. 			SListNode* cur = *head;
    15. 			while (cur->next != pos)
    16. 			{
    17. 				cur = cur->next;
    18. 			}
    19.  
    20. 			cur->next = pos->next;
    21. 			free(pos);
    22. 	}
    23.  
    24. }

    删除pos位置的下一个

    这个得保证有pos和有pos的下一个，然后保存pos的下一个，pos的next 连接上pos->next->next 然后删掉保存的pos的下一个即可~！

    1. //删除pos后一个位置
    2. void SListEraseAfter(SListNode* pos)
    3. {
    4. 	assert(pos);
    5. 	assert(pos->next);
    6.  
    7. 	SListNode* Pnext = pos->next;
    8. 	pos->next = Pnext->next;
    9. 	free(Pnext);
    10. }

    OK，测试一下：

    1. void testErase()
    2. {
    3. 	SListNode* s = NULL;//这里不置空就是野指针，会直接奔溃掉
    4. 	SListPushBack(&s, 1);
    5. 	SListPushBack(&s, 2);
    6. 	SListPushBack(&s, 3);
    7. 	SListPushBack(&s, 4);
    8. 	SListPushBack(&s, 5);
    9. 	SListPrint(s);
    10.  
    11. 	SListErase(&s, SListFind(s, 1));
    12. 	SListPrint(s);
    13. 	SListErase(&s, SListFind(s, 2));
    14. 	SListPrint(s);
    15.  
    16. 	SListEraseAfter(SListFind(s, 3));
    17. 	SListPrint(s);
    18.  
    19. 	SListDestory(&s);
    20. }

    OK，没有问题~！

    全部源码：

    1. #pragma once
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. typedef int SLDataType;
    7.  
    8. typedef struct SListNode
    9. {
    10. 	SLDataType data;
    11. 	struct SListNode* next;
    12. }SListNode;
    13.  
    14.  
    15. //动态申请一个节点
    16. SListNode* BuySListNode(SLDataType x);
    17.  
    18. //打印链表
    19. void SListPrint(SListNode* head);
    20.  
    21. //单链表的销毁
    22. void SListDestory(SListNode** head);
    23.  
    24. //尾插
    25. void SListPushBack(SListNode** head, SLDataType x);
    26.  
    27. //尾删
    28. void SListPopBack(SListNode** head);
    29.  
    30. //头插
    31. void SListPushFront(SListNode** head, SLDataType x);
    32.  
    33. //头删
    34. void SListPopFront(SListNode** head);
    35.  
    36. //单链表的查找
    37. SListNode* SListFind(SListNode* head, SLDataType x);
    38.  
    39. //在pos位置前插入
    40. void SListInsert(SListNode** head, SListNode* pos, SLDataType x);
    41.  
    42. //在pos位置后插入
    43. void SListInsertAfter(SListNode* pos, SLDataType x);
    44.  
    45. //删除pos位置
    46. void SListErase(SListNode** head, SListNode* pos);
    47.  
    48. //删除pos后一个位置
    49. void SListEraseAfter(SListNode* pos);
    50.  
    1. #include "SListNode.h"
    2.  
    3. //动态申请一个节点
    4. SListNode* BuySListNode(SLDataType x)
    5. {
    6. 	SListNode* newnode = (SListNode*)malloc (sizeof(SListNode));
    7. 	if (newnode == NULL)
    8. 	{
    9. 		perror("malloc failed");
    10. 		exit(-1);
    11. 	}
    12.  
    13. 	newnode->data = x;
    14. 	newnode->next = NULL;
    15.  
    16. 	return newnode;
    17. }
    18.  
    19. //打印链表
    20. void SListPrint(SListNode* head)
    21. {
    22. 	SListNode* cur = head;
    23. 	while (cur)
    24. 	{
    25. 		printf("%d->", cur->data);
    26. 		cur = cur->next;
    27. 	}
    28. 	printf("NULL\n");
    29. }
    30.  
    31. //单链表的销毁
    32. void SListDestory(SListNode** head)
    33. {
    34. 	assert(head);
    35.  
    36. 	SListNode* cur = *head;
    37. 	while (cur)
    38. 	{
    39. 		SListNode* next = cur->next;
    40. 		free(cur);
    41. 		cur = next;
    42. 	}
    43. 	*head = NULL;
    44. }
    45.  
    46. //尾插
    47. void SListPushBack(SListNode** head, SLDataType x)
    48. {
    49. 	assert(head);
    50. 	SListNode* node = BuySListNode(x);
    51. 	if (*head == NULL)
    52. 	{
    53. 		*head = node;
    54. 	}
    55. 	else
    56. 	{
    57. 		SListNode* cur = *head;
    58. 		while (cur->next)
    59. 		{
    60. 			cur = cur->next;
    61. 		}
    62. 		cur->next = node;
    63. 	}
    64.  
    65. }
    66.  
    67. //尾删
    68. void SListPopBack(SListNode** head)
    69. {
    70. 	assert(head);
    71. 	assert(*head);//没有节点可删
    72.  
    73. 	if ((*head)->next == NULL)
    74. 	{
    75. 		free(*head);
    76. 		*head = NULL;
    77. 	}
    78. 	else
    79. 	{
    80. 		/*SListNode* cur = *head;
    81. 		while (cur->next->next)
    82. 		{
    83. 			cur = cur->next;
    84. 		}
    85. 		free(cur->next);
    86. 		cur->next = NULL;*/
    87.  
    88. 		SListNode* cur = *head;
    89. 		SListNode* prv = NULL;
    90. 		while (cur->next)
    91. 		{
    92. 			prv = cur;
    93. 			cur = cur->next;
    94. 		}
    95. 		free(cur);
    96. 		prv->next = NULL;
    97. 	}
    98. }
    99.  
    100.  
    101. //头插
    102. void SListPushFront(SListNode** head, SLDataType x)
    103. {
    104. 	assert(head);
    105. 	SListNode* node = BuySListNode(x);
    106. 	if (*head == NULL)
    107. 	{
    108. 		*head = node;
    109. 	}
    110. 	else
    111. 	{
    112. 		node->next = *head;
    113. 		*head = node;
    114. 	}
    115. }
    116.  
    117. //头删
    118. void SListPopFront(SListNode** head)
    119. {
    120. 	assert(head);
    121. 	assert(*head);//没有节点可删
    122.  
    123. 	if ((*head)->next == NULL)
    124. 	{
    125. 		free(*head);
    126. 		*head = NULL;
    127. 	}
    128. 	else
    129. 	{
    130. 		SListNode* tail = (*head)->next;
    131. 		free(*head);
    132. 		*head = tail;
    133. 	}
    134. }
    135.  
    136. //单链表的查找
    137. SListNode* SListFind(SListNode* head, SLDataType x)
    138. {
    139. 	SListNode* cur = head;
    140. 	while (cur)
    141. 	{
    142. 		if (x == cur->data)
    143. 			return  cur;
    144.  
    145. 		cur = cur->next;
    146. 	}
    147.  
    148. 	return NULL;
    149. }
    150.  
    151. //在pos位置前插入
    152. void SListInsert(SListNode** head, SListNode* pos, SLDataType x)
    153. {
    154. 	assert(head);
    155. 	assert(pos);
    156.  
    157. 	SListNode* node = BuySListNode(x);
    158. 	if (*head == NULL)
    159. 	{
    160. 		node->next = *head;
    161. 		*head = node;
    162. 	}
    163. 	else
    164. 	{
    165. 		SListNode* cur = *head;
    166. 		while (cur)
    167. 		{
    168. 			if (cur->next == pos)
    169. 			{
    170. 				node->next = pos;
    171. 				cur->next = node;
    172. 				break;
    173. 			}
    174. 			cur = cur->next;
    175. 		}
    176. 	}
    177.  
    178. }
    179.  
    180. //在pos位置后插入
    181. void SListInsertAfter(SListNode* pos, SLDataType x)
    182. {
    183. 	assert(pos);
    184.  
    185. 	SListNode* node = BuySListNode(x);
    186. 	node->next = pos->next;
    187. 	pos->next = node;
    188. }
    189.  
    190. //删除pos位置
    191. void SListErase(SListNode** head, SListNode* pos)
    192. {
    193. 	assert(head);
    194. 	assert(*head);//空了就不要删了
    195. 	assert(pos);
    196.  
    197. 	if (*head == pos)
    198. 	{
    199. 		SListPopFront(head);
    200. 	}
    201. 	else
    202. 	{
    203. 			SListNode* cur = *head;
    204. 			while (cur->next != pos)
    205. 			{
    206. 				cur = cur->next;
    207. 			}
    208.  
    209. 			cur->next = pos->next;
    210. 			free(pos);
    211. 	}
    212.  
    213. }
    214.  
    215. //删除pos后一个位置
    216. void SListEraseAfter(SListNode* pos)
    217. {
    218. 	assert(pos);
    219. 	assert(pos->next);
    220.  
    221. 	SListNode* Pnext = pos->next;
    222. 	pos->next = Pnext->next;
    223. 	free(Pnext);
    224. }
    1. #include "SListNode.h"
    2.  
    3. void testBack()
    4. {
    5. 	SListNode* s = NULL;//这里不置空就是野指针，会直接奔溃掉
    6. 	SListPushBack(&s, 1);
    7. 	SListPushBack(&s, 2);
    8. 	SListPushBack(&s, 3);
    9. 	SListPushBack(&s, 4);
    10. 	SListPushBack(&s, 5);
    11. 	SListPrint(s);
    12.  
    13. 	SListPopBack(&s);
    14. 	SListPrint(s);
    15.  
    16. 	SListPopBack(&s);
    17. 	SListPrint(s);
    18. 	SListPopBack(&s);
    19. 	SListPrint(s);
    20. 	SListPopBack(&s);
    21. 	SListPrint(s);
    22.  
    23. 	SListPopBack(&s);
    24. 	SListPrint(s);
    25. 	//SListPopBack(&s);//测试尾删是否有Bug
    26. 	//SListPrint(s);
    27.  
    28. 	SListDestory(&s);
    29. }
    30.  
    31. void testFront()
    32. {
    33. 	SListNode* s = NULL;
    34. 	SListPushFront(&s, 1);
    35. 	SListPushFront(&s, 2);
    36. 	SListPushFront(&s, 3);
    37. 	SListPushFront(&s, 4);
    38. 	SListPushFront(&s, 5);
    39. 	SListPrint(s);
    40.  
    41. 	SListPopFront(&s);
    42. 	SListPrint(s);
    43. 	SListPopFront(&s);
    44. 	SListPrint(s);
    45. 	SListPopFront(&s);
    46. 	SListPrint(s);
    47. 	SListPopFront(&s);
    48. 	SListPrint(s);
    49. 	SListPopFront(&s);
    50. 	SListPrint(s);
    51. 	//SListPopFront(&s);//测试头删是是否有Bug
    52. 	//SListPrint(s);
    53.  
    54. 	SListDestory(&s);
    55. }
    56.  
    57. testInsert()
    58. {
    59. 	SListNode* s = NULL;
    60. 	SListPushFront(&s, 1);
    61. 	SListPushFront(&s, 2);
    62. 	SListPushFront(&s, 3);
    63. 	SListPushFront(&s, 4);
    64. 	SListPushFront(&s, 5);
    65. 	SListPrint(s);
    66.  
    67. 	SListInsert(&s, SListFind(s, 1), 10);
    68. 	SListPrint(s);
    69. 	SListInsert(&s, SListFind(s, 1), 100);
    70. 	SListPrint(s);
    71.  
    72. 	SListInsertAfter(SListFind(s, 4), 40);
    73. 	SListPrint(s);
    74. 	SListDestory(&s);
    75. }
    76.  
    77. void testErase()
    78. {
    79. 	SListNode* s = NULL;//这里不置空就是野指针，会直接奔溃掉
    80. 	SListPushBack(&s, 1);
    81. 	SListPushBack(&s, 2);
    82. 	SListPushBack(&s, 3);
    83. 	SListPushBack(&s, 4);
    84. 	SListPushBack(&s, 5);
    85. 	SListPrint(s);
    86.  
    87. 	SListErase(&s, SListFind(s, 1));
    88. 	SListPrint(s);
    89. 	SListErase(&s, SListFind(s, 2));
    90. 	SListPrint(s);
    91.  
    92. 	SListEraseAfter(SListFind(s, 3));
    93. 	SListPrint(s);
    94.  
    95. 	SListDestory(&s);
    96. }
    97.  
    98. int main()
    99. {
    100. 	//testBack();
    101. 	//testFront();
    102. 	//testInsert();
    103. 	testErase();
    104. 	return 0;
    105. }

    OK，无头（没有哨兵位的头结点）单链表就到这里~！这应该是我们介绍的三个里面最复杂的一个~！如果这个掌握了那其他的很容易~！下面我们来看看带哨兵位的头结点的单链表~！

    四、单链表的实现（带头）

    还是和没有头的一样先声明每个节点的类型：

    链表结点类型声明

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

    链表初始化

    由于前面是不带头的，所以不需要进行初始化，而这里现在是带哨兵位头结点的~！一开始得要处理好头结点~！处理的方式有两种，一种是在初始的时候无返回值需要传一次二级，其他地方都不用，这显得有点突兀，所以我们采用第二种返回值，将处理好的头结点的地址返回外面接收此时就是带头的了。其实还有一种就是再定义一个结构体，里面是专门维护这个链表的指针，传一级指针也是可以的~~！当然这里采用返回值的方式！

    1. //链表的初始化
    2. SLNode* SLInit()
    3. {
    4. 	SLNode* head = (SLNode*)malloc(sizeof(SLNode));
    5. 	if (head == NULL)
    6. 	{
    7. 		perror("head malloc failed");
    8. 		exit(-1);
    9. 	}
    10. 	head->next = NULL;
    11.  
    12. 	return head;
    13. }

    链表的销毁

    这里销毁也是一样有两种方式一种是传二级啥都不管了，内部会处理好但这里人家都是一级你一个二级显得有些突兀，还有一种就是不传二级外面最后记得把头置空即可！我们这里就采用第二种！

    1. //链表的销毁
    2. void SLDestory(SLNode* head)
    3. {
    4. 	assert(head);//头结点不可能为空
    5. 	SLNode* cur = head;
    6. 	while (cur)
    7. 	{
    8. 		SLNode* tail = cur->next;
    9. 		free(cur);
    10. 		cur = tail;
    11. 	}
    12. }

    链表的打印

    1. //链表的打印
    2. void SLPrint(SLNode* head)
    3. {
    4. 	assert(head);
    5.  
    6. 	SLNode* cur = head->next;
    7. 	while (cur)
    8. 	{
    9. 		printf("%d->", cur->data);
    10. 		cur = cur->next;
    11. 	}
    12. 	printf("NULL\n");
    13. }

    动态开辟一个节点

    由于后面会有大量的插入，每次插入都要开新节点，所以我们直接把他封装成一个函数，后续调用起来方便，代码简洁~！

    1. //动态开辟一个节点
    2. SLNode* BuyNode(SLDataType x)
    3. {
    4. 	SLNode* node = (SLNode*)malloc(sizeof(SLNode));
    5. 	if (node == NULL)
    6. 	{
    7. 		perror("malloc failed");
    8. 		exit(-1);
    9. 	}
    10. 	node->data = x;
    11. 	node->next = NULL;
    12.  
    13. 	return node;
    14. }

    单链表尾插

    由于有头结点，可以不因考虑第一个插入的情况，另外这里的head是头结点，即使链表为空他也不可能为空！因此为了代码的健壮性断言一下还是好的~！

    1.  
    2. //尾插
    3. void SLPushBack(SLNode* head, SLDataType x)
    4. {
    5. 	assert(head);
    6. 	SLNode* newnode = BuyNode(x);
    7.  
    8. 	SLNode* cur = head;
    9. 	while (cur->next)
    10. 	{
    11. 		cur = cur->next;
    12. 	}
    13.  
    14. 	cur->next = newnode;
    15. }

    单链表的尾删

    尾删也不许担心删完后置头结点为空，这里带了哨兵位的头不需要担心直接删即可，另外这里还是有两种方法上面已经说过，这里采用非快慢指针法~！

    1. //尾删
    2. void SLPopBack(SLNode* head)
    3. {
    4. 	assert(head);
    5. 	assert(head->next);//空链表
    6. 	SLNode* cur = head;
    7.  
    8. 	while (cur->next->next)
    9. 	{
    10. 		cur = cur->next;
    11. 	}
    12.  
    13. 	free(cur->next);
    14. 	cur->next = NULL;
    15. }

    OK，来测试一把：

    1. void testBack()
    2. {
    3. 	SLNode* s = SLInit();
    4. 	SLPushBack(s, 1);
    5. 	SLPushBack(s, 2);
    6. 	SLPushBack(s, 3);
    7. 	SLPrint(s);
    8.  
    9. 	SLPopBack(s);
    10. 	SLPrint(s);
    11. 	SLPopBack(s);
    12. 	SLPrint(s);
    13. 	SLPopBack(s);
    14. 	SLPrint(s);
    15. 	//SLPopBack(s);//检测尾删是否有Bug
    16. 	//SLPrint(s);
    17.  
    18. 	SLDestory(s);
    19. 	s = NULL;//记得把头置空，避免野指针
    20. }

    OK，没有问题，这个是不是相较于上面没带哨兵位的头结点的那个简单多了~！哈哈，OK，我们再来实现一下，头插、头删~！

    单链表头插

    这相比上面的就很简单了，直接插在哨兵位头结点的后面即可！不用考虑第一个插入改变头的情况~！

    1. //头插
    2. void SLPushFront(SLNode* head, SLDataType x)
    3. {
    4. 	assert(head);
    5.  
    6. 	SLNode* newnode = BuyNode(x);
    7. 	newnode->next = head->next;
    8. 	head->next = newnode;
    9. }

    单链表的头删

    头删也是比以前的简单，只需判空即可，不需要考虑改变头的问题~！

    1. //头删
    2. void SLPopFront(SLNode* head)
    3. {
    4. 	assert(head);
    5. 	assert(head->next);//无节点可删
    6.  
    7. 	SLNode* del = head->next;
    8. 	head->next = del->next;
    9. 	free(del);
    10. }

    OK，还是来测试一波：

    1. void testFront()
    2. {
    3. 	SLNode* s = SLInit();
    4. 	SLPushFront(s, 1);
    5. 	SLPushFront(s, 2);
    6. 	SLPushFront(s, 3);
    7. 	SLPushFront(s, 4);
    8. 	SLPrint(s);
    9.  
    10. 	SLPopFront(s);
    11. 	SLPrint(s);
    12. 	SLPopFront(s);
    13. 	SLPrint(s);
    14. 	SLPopFront(s);
    15. 	SLPrint(s);
    16. 	SLPopFront(s);
    17. 	SLPrint(s);
    18. 	//SLPopFront(s);//测试头删是否有Bug
    19. 	//SLPrint(s);
    20.  
    21. 	SLDestory(s);
    22. 	s = NULL;//记得把头置空，避免野指针
    23. }

    单链表查找

    还是和前面一样找到了返回当前节点的地址，否则返回NULL。

    1. //单链表的查找
    2. SLNode* SLFind(SLNode* head, SLDataType x)
    3. {
    4. 	assert(head);
    5.  
    6. 	SLNode* cur = head->next;
    7. 	while (cur)
    8. 	{
    9. 		if (x == cur->data)
    10. 			return cur;
    11.  
    12. 		cur = cur->next;
    13. 	}
    14.  
    15. 	return NULL;
    16. }

    这里肯定有小伙伴问这个函数不就查找吗，除了配合insert和erase插入删除还能干啥？其实他还能修改信息~！数据结构学的是数据的物理存储结构、逻辑顺序结构和运算~！这里的运算简单点就是增删查改。上面无头的我们已经进行了增删查，没有实现改（其实是我忘了，刚刚想起哈哈），这里我们可以补在这个上，上面无头的也是一样的~！！！

    单链表修改

    1. //单链表的修改
    2. void SLModif(SLNode* head, SLDataType x, SLDataType y)
    3. {
    4. 	assert(head);
    5.  
    6. 	SLNode* ret = SLFind(head, x);
    7. 	assert(ret);
    8. 	ret->data = y;
    9. }

    在pos前插入

    逻辑和上面的一样，这里也不用考虑第一个插入要改变头的情况~！

    1. //在pos前插入
    2. void SLInsert(SLNode* head, SLNode* pos, SLDataType x)
    3. {
    4. 	assert(head);
    5. 	assert(pos);
    6.  
    7. 	SLNode* newnode = BuyNode(x);
    8. 	SLNode* cur = head;
    9. 	while (cur->next != pos)
    10. 	{
    11. 		cur = cur->next;
    12. 	}
    13.  
    14. 	newnode->next = pos;
    15. 	cur->next = newnode;
    16. }

    在pos后插入

    1. //在pos后插入
    2. void SLInsertAfter(SLNode* pos, SLDataType x)
    3. {
    4. 	assert(pos);
    5.  
    6. 	SLNode* newnode = BuyNode(x);
    7. 	newnode->next = pos->next;
    8. 	pos->next = newnode;
    9. }

    OK，则是一波走起：（这里就把修改顺便测了）

    1. void testInsert()
    2. {
    3. 	SLNode* s = SLInit();
    4. 	SLPushBack(s, 1);
    5. 	SLPushBack(s, 2);
    6. 	SLPushBack(s, 3);
    7. 	SLPrint(s);
    8.  
    9. 	SLInsert(s, SLFind(s, 1), 10);
    10. 	SLPrint(s);
    11. 	SLInsertAfter(SLFind(s, 2), 200);
    12. 	SLPrint(s);
    13.  
    14. 	SLModif(s, 3, 300);
    15. 	SLPrint(s);
    16.  
    17. 	SLDestory(s);
    18. 	s = NULL;//记得把头置空，避免野指针
    19. }

    OK，没有问题~！再来实现两个erase的接口！

    删除pos位置

    这里由于是SLFind配合删除的，所以不因担心删完多删的情况！

    1. //删除pos位置
    2. void SLErase(SLNode* head, SLNode* pos)
    3. {
    4. 	assert(head);
    5. 	assert(pos);
    6.  
    7. 	SLNode* cur = head;
    8. 	while (cur->next != pos)
    9. 	{
    10. 		cur = cur->next;
    11. 	}
    12.  
    13. 	cur->next = pos->next;
    14. 	free(pos);
    15. }

    删除pos后一个

    唯一要注意的是pos得有下一个才让删除，否则结束~！

    1. //删除pos位置的后一个
    2. void SLEraseAfter(SLNode* pos)
    3. {
    4. 	assert(pos);
    5. 	assert(pos->next);
    6.  
    7. 	SLNode* del = pos->next;
    8. 	pos->next = del->next;
    9. 	free(del);
    10. }

    链表的长度

    这里多加的一个接口是获取链表的长度~！这个不难很容易~！

    1. //获取链表的长度
    2. int SLSize(SLNode* head)
    3. {
    4. 	assert(head);
    5.  
    6. 	int size = 0;
    7. 	SLNode* cur = head->next;
    8. 	while (cur)
    9. 	{
    10. 		++size;
    11. 		cur = cur->next;
    12. 	}
    13.  
    14. 	return size;
    15. }

    OK，测试一把：

    1. void testErase()
    2. {
    3. 	SLNode* s = SLInit();
    4. 	SLPushBack(s, 1);
    5. 	SLPushBack(s, 2);
    6. 	SLPushBack(s, 3);
    7. 	SLPushBack(s, 4);
    8. 	SLPrint(s);
    9.  
    10. 	SLErase(s, SLFind(s, 1));
    11. 	SLPrint(s);
    12.  
    13. 	SLEraseAfter(SLFind(s, 2));
    14. 	SLPrint(s);
    15.  
    16. 	printf("size = %d\n", SLSize(s));
    17.  
    18. 	SLDestory(s);
    19. 	s = NULL;//记得把头置空，避免野指针
    20. }

    OK，没有问题~！

    总结：

    带哨兵位的头结点的确比不带头的要简单很多！这两种都很重要以后工作中常用的就是这两种和下面要介绍的带头双向循环链表~！而且他这里插入和删除可以用Insert和Erase简化！

    全部源码：

    1. #pragma once
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. typedef int SLDataType;
    7. typedef struct SListNode
    8. {
    9. 	SLDataType data;
    10. 	struct SListNode* next;
    11. }SLNode;
    12.  
    13.  
    14. //链表的初始化
    15. SLNode* SLInit();
    16.  
    17. //链表的销毁
    18. void SLDestory(SLNode* head);
    19.  
    20. //链表的打印
    21. void SLPrint(SLNode* head);
    22.  
    23. //动态开辟一个节点
    24. SLNode* BuyNode(SLDataType x);
    25.  
    26. //尾插
    27. void SLPushBack(SLNode* head, SLDataType x);
    28.  
    29. //尾删
    30. void SLPopBack(SLNode* head);
    31.  
    32. //头插
    33. void SLPushFront(SLNode* head, SLDataType x);
    34.  
    35. //头删
    36. void SLPopFront(SLNode* head);
    37.  
    38. //单链表的查找
    39. SLNode* SLFind(SLNode* head, SLDataType x);
    40.  
    41. //单链表的修改
    42. void SLModif(SLNode* head, SLDataType x, SLDataType y);
    43.  
    44. //在pos前插入
    45. void SLInsert(SLNode* head, SLNode* pos, SLDataType x);
    46.  
    47. //在pos后插入
    48. void SLInsertAfter(SLNode* pos, SLDataType x);
    49.  
    50. //删除pos位置
    51. void SLErase(SLNode* head, SLNode* pos);
    52.  
    53. //删除pos位置的后一个
    54. void SLEraseAfter(SLNode* pos);
    55.  
    56. //获取链表的长度
    57. int SLSize(SLNode* head);
    1. #include "SLT.h"
    2.  
    3. //链表的初始化
    4. SLNode* SLInit()
    5. {
    6. 	SLNode* head = (SLNode*)malloc(sizeof(SLNode));
    7. 	if (head == NULL)
    8. 	{
    9. 		perror("head malloc failed");
    10. 		exit(-1);
    11. 	}
    12. 	head->next = NULL;
    13.  
    14. 	return head;
    15. }
    16.  
    17. //链表的销毁
    18. void SLDestory(SLNode* head)
    19. {
    20. 	assert(head);//头结点不可能为空
    21. 	SLNode* cur = head;
    22. 	while (cur)
    23. 	{
    24. 		SLNode* tail = cur->next;
    25. 		free(cur);
    26. 		cur = tail;
    27. 	}
    28. }
    29.  
    30.  
    31. //链表的打印
    32. void SLPrint(SLNode* head)
    33. {
    34. 	assert(head);
    35.  
    36. 	SLNode* cur = head->next;
    37. 	while (cur)
    38. 	{
    39. 		printf("%d->", cur->data);
    40. 		cur = cur->next;
    41. 	}
    42. 	printf("NULL\n");
    43. }
    44.  
    45.  
    46. //动态开辟一个节点
    47. SLNode* BuyNode(SLDataType x)
    48. {
    49. 	SLNode* node = (SLNode*)malloc(sizeof(SLNode));
    50. 	if (node == NULL)
    51. 	{
    52. 		perror("malloc failed");
    53. 		exit(-1);
    54. 	}
    55. 	node->data = x;
    56. 	node->next = NULL;
    57.  
    58. 	return node;
    59. }
    60.  
    61. //尾插
    62. void SLPushBack(SLNode* head, SLDataType x)
    63. {
    64. 	assert(head);
    65. 	SLNode* newnode = BuyNode(x);
    66.  
    67. 	SLNode* cur = head;
    68. 	while (cur->next)
    69. 	{
    70. 		cur = cur->next;
    71. 	}
    72.  
    73. 	cur->next = newnode;
    74. }
    75.  
    76.  
    77. //尾删
    78. void SLPopBack(SLNode* head)
    79. {
    80. 	assert(head);
    81. 	assert(head->next);//空链表
    82. 	SLNode* cur = head;
    83.  
    84. 	while (cur->next->next)
    85. 	{
    86. 		cur = cur->next;
    87. 	}
    88.  
    89. 	free(cur->next);
    90. 	cur->next = NULL;
    91. }
    92.  
    93. //头插
    94. void SLPushFront(SLNode* head, SLDataType x)
    95. {
    96. 	assert(head);
    97.  
    98. 	SLNode* newnode = BuyNode(x);
    99. 	newnode->next = head->next;
    100. 	head->next = newnode;
    101. }
    102.  
    103. //头删
    104. void SLPopFront(SLNode* head)
    105. {
    106. 	assert(head);
    107. 	assert(head->next);//无节点可删
    108.  
    109. 	SLNode* del = head->next;
    110. 	head->next = del->next;
    111. 	free(del);
    112. }
    113.  
    114. //单链表的查找
    115. SLNode* SLFind(SLNode* head, SLDataType x)
    116. {
    117. 	assert(head);
    118.  
    119. 	SLNode* cur = head->next;
    120. 	while (cur)
    121. 	{
    122. 		if (x == cur->data)
    123. 			return cur;
    124.  
    125. 		cur = cur->next;
    126. 	}
    127.  
    128. 	return NULL;
    129. }
    130.  
    131. //单链表的修改
    132. void SLModif(SLNode* head, SLDataType x, SLDataType y)
    133. {
    134. 	assert(head);
    135.  
    136. 	SLNode* ret = SLFind(head, x);
    137. 	assert(ret);
    138. 	ret->data = y;
    139. }
    140.  
    141. //在pos前插入
    142. void SLInsert(SLNode* head, SLNode* pos, SLDataType x)
    143. {
    144. 	assert(head);
    145. 	assert(pos);
    146.  
    147. 	SLNode* newnode = BuyNode(x);
    148. 	SLNode* cur = head;
    149. 	while (cur->next != pos)
    150. 	{
    151. 		cur = cur->next;
    152. 	}
    153.  
    154. 	newnode->next = pos;
    155. 	cur->next = newnode;
    156. }
    157.  
    158. //在pos后插入
    159. void SLInsertAfter(SLNode* pos, SLDataType x)
    160. {
    161. 	assert(pos);
    162.  
    163. 	SLNode* newnode = BuyNode(x);
    164. 	newnode->next = pos->next;
    165. 	pos->next = newnode;
    166. }
    167.  
    168. //删除pos位置
    169. void SLErase(SLNode* head, SLNode* pos)
    170. {
    171. 	assert(head);
    172. 	assert(pos);
    173.  
    174. 	SLNode* cur = head;
    175. 	while (cur->next != pos)
    176. 	{
    177. 		cur = cur->next;
    178. 	}
    179.  
    180. 	cur->next = pos->next;
    181. 	free(pos);
    182. }
    183.  
    184. //删除pos位置的后一个
    185. void SLEraseAfter(SLNode* pos)
    186. {
    187. 	assert(pos);
    188. 	assert(pos->next);
    189.  
    190. 	SLNode* del = pos->next;
    191. 	pos->next = del->next;
    192. 	free(del);
    193. }
    194.  
    195. //获取链表的长度
    196. int SLSize(SLNode* head)
    197. {
    198. 	assert(head);
    199.  
    200. 	int size = 0;
    201. 	SLNode* cur = head->next;
    202. 	while (cur)
    203. 	{
    204. 		++size;
    205. 		cur = cur->next;
    206. 	}
    207.  
    208. 	return size;
    209. }
    1. #include "SLT.h"
    2.  
    3. void testBack()
    4. {
    5. 	SLNode* s = SLInit();
    6. 	SLPushBack(s, 1);
    7. 	SLPushBack(s, 2);
    8. 	SLPushBack(s, 3);
    9. 	SLPrint(s);
    10. 	SLPopBack(s);
    11. 	SLPrint(s);
    12. 	SLPopBack(s);
    13. 	SLPrint(s);
    14. 	SLPopBack(s);
    15. 	SLPrint(s);
    16. 	//SLPopBack(s);//检测尾删是否有Bug
    17. 	//SLPrint(s);
    18. 	SLDestory(s);
    19. 	s = NULL;//记得把头置空，避免野指针
    20. }
    21.  
    22. void testFront()
    23. {
    24. 	SLNode* s = SLInit();
    25. 	SLPushFront(s, 1);
    26. 	SLPushFront(s, 2);
    27. 	SLPushFront(s, 3);
    28. 	SLPushFront(s, 4);
    29. 	SLPrint(s);
    30. 	SLPopFront(s);
    31. 	SLPrint(s);
    32. 	SLPopFront(s);
    33. 	SLPrint(s);
    34. 	SLPopFront(s);
    35. 	SLPrint(s);
    36. 	SLPopFront(s);
    37. 	SLPrint(s);
    38. 	//SLPopFront(s);//测试头删是否有Bug
    39. 	//SLPrint(s);
    40.  
    41. 	SLDestory(s);
    42. 	s = NULL;//记得把头置空，避免野指针
    43. }
    44.  
    45. void testInsert()
    46. {
    47. 	SLNode* s = SLInit();
    48. 	SLPushBack(s, 1);
    49. 	SLPushBack(s, 2);
    50. 	SLPushBack(s, 3);
    51. 	SLPrint(s);
    52.  
    53. 	SLInsert(s, SLFind(s, 1), 10);
    54. 	SLPrint(s);
    55. 	SLInsertAfter(SLFind(s, 2), 200);
    56. 	SLPrint(s);
    57.  
    58. 	SLModif(s, 3, 300);
    59. 	SLPrint(s);
    60.  
    61. 	SLDestory(s);
    62. 	s = NULL;//记得把头置空，避免野指针
    63. }
    64.  
    65. void testErase()
    66. {
    67. 	SLNode* s = SLInit();
    68. 	SLPushBack(s, 1);
    69. 	SLPushBack(s, 2);
    70. 	SLPushBack(s, 3);
    71. 	SLPushBack(s, 4);
    72. 	SLPrint(s);
    73.  
    74. 	SLErase(s, SLFind(s, 1));
    75. 	SLPrint(s);
    76.  
    77. 	SLEraseAfter(SLFind(s, 2));
    78. 	SLPrint(s);
    79.  
    80. 	printf("size = %d\n", SLSize(s));
    81.  
    82. 	SLDestory(s);
    83. 	s = NULL;//记得把头置空，避免野指针
    84. }
    85.  
    86. int main()
    87. {
    88. 	//testBack();
    89. 	//testFront();
    90. 	//testInsert();
    91. 	testErase();
    92. 	return 0;
    93. }

    五、带头双向循环链表的实现

    我们上面实现的两种都是单链表，他们头插头删的效率很高，但在中间或尾部插入删除时的效率就很低，为了解决这个问题我们在定义节点类型时在加入一个前驱指针来记录当前节点的前一个节点的地址，这样插入删除就很OK了~！当最后一个时让他的后继指针指向头结点，第一个的前驱指向最后一个节点，这样就实现了循环而且任何节点的插入删除都很高~！OK，下面是图：

    OK，下面我们就来实现一下~！

    结点类型声明

    1. typedef int LTDataType;
    2. typedef struct ListNode
    3. {
    4. 	LTDataType data;
    5. 	struct ListNode* prv;
    6. 	struct ListNode* next;
    7. }ListNode;

    初始化

    1. //初始化
    2. ListNode* ListInit()
    3. {
    4. 	ListNode* head = (ListNode*)malloc(sizeof(ListNode));
    5. 	if (!head)
    6. 	{
    7. 		perror("malloc failed");
    8. 		exit(-1);
    9. 	}
    10.  
    11. 	head->prv = head;
    12. 	head->next = head;
    13.  
    14. 	return head;
    15. }

    销毁

    这里与上面单向带有不一样的是！这里因为是循环的最后的next指向哨兵位的头，所以不能和上面一样直接从head开始销毁，应该从head->next开始等所有的销毁完了，在把head置空即可~！这是因为是一级指针所以外面的调用者在最后记得置空head~！

    1. //销毁
    2. void ListDestory(ListNode* head)
    3. {
    4. 	assert(head);
    5.  
    6. 	ListNode* cur = head->next;
    7. 	while (cur != head)
    8. 	{
    9. 		ListNode* tail = cur->next;
    10. 		free(cur);
    11. 		cur = tail;
    12. 	}
    13.  
    14. 	free(head);
    15. }

    打印

    1. //链表的打印
    2. void ListPrint(ListNode* head)
    3. {
    4. 	assert(head);
    5.  
    6. 	ListNode* cur = head->next;
    7. 	while (cur != head)
    8. 	{
    9. 		printf("%d->", cur->data);
    10. 		cur = cur->next;
    11. 	}
    12. }

    动态开辟新节点

    1. //动态开辟一个节点
    2. ListNode* BuyNode(LTDataType x)
    3. {
    4. 	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
    5. 	if (!node)
    6. 	{
    7. 		perror("malloc failed");
    8. 		exit(-1);
    9. 	}
    10.  
    11. 	node->data = x;
    12. 	node->prv = NULL;
    13. 	node->next = NULL;
    14.  
    15. 	return node;
    16. }

    尾插

    这里比单链表好的就是不用遍历找尾直接就可以找到，但注意的是要把prv前驱指针处理好~！如果不熟练可以多定义个指针，如果熟悉了就可以多个->next->prv哈哈~！下面是两种写法！

    1. //尾插
    2. void ListPushBack(ListNode* head, LTDataType x)
    3. {
    4. 	assert(head);
    5.  
    6. 	ListNode* newnode = BuyNode(x);
    7. 	ListNode* tail = head->prv;
    8. 	tail->next = newnode;
    9. 	newnode->prv = tail;
    10. 	newnode->next = head;
    11. 	head->prv = newnode;
    12.  
    13. 	/*head->prv->next = newnode;
    14. 	newnode->prv = head->prv;
    15. 	newnode->next = head;
    16. 	head->prv = newnode;*/
    17. }

    尾删

    尾删也是一样可以多定义指针也可以直接来！也要注意处理好前驱~！下面是两种方式！

    1. //尾删
    2. void ListPopBack(ListNode* head)
    3. {
    4. 	assert(head);
    5. 	assert(head->next != head);//链表为空
    6.  
    7. 	ListNode* tail = head->prv;
    8. 	ListNode* tailPrv = tail->prv;
    9.  
    10. 	tailPrv->next = head;
    11. 	head->prv = tailPrv;
    12. 	free(tail);
    13.  
    14. 	/*ListNode* del = head->prv;
    15. 	head->prv->prv->next = head;
    16. 	head->prv = head->prv->prv;
    17. 	free(del);*/
    18. }

    OK还是测试一波：

    1. void testBack()
    2. {
    3. 	ListNode* L = ListInit();
    4. 	ListPushBack(L, 1);
    5. 	ListPushBack(L, 2);
    6. 	ListPushBack(L, 3);
    7. 	ListPrint(L);
    8.  
    9. 	ListPopBack(L);
    10. 	ListPrint(L);
    11. 	ListPopBack(L);
    12. 	ListPrint(L);
    13. 	ListPopBack(L);
    14. 	ListPrint(L);
    15. 	//ListPopBack(L);//测试尾删是否有Bug
    16. 	//ListPrint(L);
    17.  
    18. 	ListDestory(L);
    19. 	L = NULL;
    20. }

    OK，没有问题，再来搞两个头插和头删~！

    头插

    1. //头插
    2. void ListPushFront(ListNode* head, LTDataType x)
    3. {
    4. 	assert(head);
    5.  
    6. 	ListNode* newnode = BuyNode(x);
    7. 	ListNode* tail = head->next;
    8. 	newnode->next = tail;
    9. 	tail->prv = newnode;
    10. 	head->next = newnode;
    11. 	newnode->prv = head;
    12.  
    13. 	/*newnode->next = head->next;
    14. 	head->next->prv = newnode;
    15. 	head->next = newnode;
    16. 	newnode->prv = head;*/
    17. }

    头删 

    1. //头删
    2. void ListPopFront(ListNode* head)
    3. {
    4. 	assert(head);
    5. 	assert(head->next != head);
    6.  
    7. 	ListNode* del = head->next;
    8. 	head->next = del->next;
    9. 	del->next->prv = head;
    10. 	free(del);
    11. }

    OK，来测试一波：

    1. void testFront()
    2. {
    3. 	ListNode* L = ListInit();
    4. 	ListPushFront(L, 1);
    5. 	ListPushFront(L, 2);
    6. 	ListPushFront(L, 3);
    7. 	ListPrint(L);
    8.  
    9. 	ListPopFront(L);
    10. 	ListPrint(L);
    11. 	ListPopFront(L);
    12. 	ListPrint(L);
    13. 	ListPopFront(L);
    14. 	ListPrint(L);
    15. 	//ListPopFront(L);//测试头删是否有Bug
    16. 	//ListPrint(L);
    17.  
    18. 	ListDestory(L);
    19. 	L = NULL;
    20. }

    OK，没有bug！我们继续：

    查找

    这里还是和前面一样找到了返回当前节点的地址否则返回NULL,实际上在很多常见下就是这样的~！

    1. //查找
    2. ListNode* ListFind(ListNode* head, LTDataType x)
    3. {
    4. 	assert(head);
    5.  
    6. 	ListNode* cur = head->next;
    7. 	while (cur != head)
    8. 	{
    9. 		if (x == cur->data)
    10. 			return cur;
    11.  
    12. 		cur = cur->next;
    13. 	}
    14.  
    15. 	return NULL;
    16. }

    修改

    记得判断找不到的情况，我这里采用的是暴力检查！！！

    1. //修改
    2. void ListModif(ListNode* head, LTDataType x, LTDataType y)
    3. {
    4. 	assert(head);
    5.  
    6. 	ListNode* ret = ListFind(head, x);
    7. 	assert(ret);
    8. 	ret->data = y;
    9. }

    在pos前插入

    这里注意的是由于查找函数已经把pos查找好了，且有前驱指针所以不需要遍历找pos,直接链接即可~！

    1. //在pos前插入
    2. void ListInsert( ListNode* pos, LTDataType x)
    3. {
    4. 	assert(pos);
    5.  
    6. 	ListNode* newnode = BuyNode(x);
    7. 	ListNode* Prv = pos->prv;
    8. 	newnode->next = pos;
    9. 	pos->prv = newnode;
    10. 	Prv->next = newnode;
    11. 	newnode->prv = Prv;
    12. }

    在pos后插入

    1. //在pos后插入
    2. void ListInsertAfter(ListNode* pos, LTDataType x)
    3. {
    4. 	assert(pos);
    5.  
    6. 	ListNode* newnode = BuyNode(x);
    7. 	ListNode* tail = pos->next;
    8. 	newnode->next = tail;
    9. 	tail->prv = newnode;
    10. 	pos->next = newnode;
    11. 	newnode->prv = pos;
    12. }

    OK，测试一波：

    1. void testInsert()
    2. {
    3. 	ListNode* L = ListInit();
    4. 	ListPushBack(L, 1);
    5. 	ListPushBack(L, 2);
    6. 	ListPushBack(L, 3);
    7. 	ListPrint(L);
    8.  
    9. 	ListInsert(ListFind(L, 1), 10);
    10. 	ListPrint(L);
    11.  
    12. 	ListInsertAfter(ListFind(L, 3), 300);
    13. 	ListPrint(L);
    14.  
    15. 	ListDestory(L);
    16. 	L = NULL;
    17. }

    OK，没有问题~！

    删除pos

    1. //删除pos位置
    2. void ListErase(ListNode* pos)
    3. {
    4. 	assert(pos);
    5.  
    6. 	ListNode* Prv = pos->prv;
    7. 	ListNode* tail = pos->next;
    8. 	Prv->next = tail;
    9. 	tail->prv = Prv;
    10. 	free(pos);
    11. }

    删除pos的下一个

    这里得注意的是又是是循环的。如果pos没有下一个就指向head,所以判断有没有pos的下一个必须有头~！！！

    1. //删除pos位置的下一个
    2. void ListEraseAfter(ListNode* head, ListNode* pos)
    3. {
    4. 	assert(pos);
    5. 	assert(pos->next != head);//没有下一个节点可删
    6.  
    7. 	ListNode* tail = pos->next;
    8. 	pos->next = tail->next;
    9. 	tail->prv = pos;
    10. 	free(tail);
    11. }

    OK，测试一把~！

    1. void testErase()
    2. {
    3. 	ListNode* L = ListInit();
    4. 	ListPushBack(L, 1);
    5. 	ListPushBack(L, 2);
    6. 	ListPushBack(L, 3);
    7. 	ListPrint(L);
    8.  
    9. 	ListErase(ListFind(L, 1));
    10. 	ListPrint(L);
    11.  
    12. 	ListEraseAfter(L, ListFind(L, 2));
    13. 	ListPrint(L);
    14.  
    15. 	ListDestory(L);
    16. 	L = NULL;
    17. }

    没有问题，上面有个修改函数忘了测试了，等在写一个长度一起在这个里面测试了：

    获取长度

    1. //获取链表的长度
    2. int ListSize(ListNode* head)
    3. {
    4. 	assert(head);
    5.  
    6. 	int size = 0;
    7. 	ListNode* cur = head->next;
    8. 	while (cur != head)
    9. 	{
    10. 		++size;
    11. 		cur = cur->next;
    12. 	}
    13.  
    14. 	return size;
    15. }

    OK，测试一下：

    1. void testErase()
    2. {
    3. 	ListNode* L = ListInit();
    4. 	ListPushBack(L, 1);
    5. 	ListPushBack(L, 2);
    6. 	ListPushBack(L, 3);
    7. 	ListPrint(L);
    8. 	printf("size = %d\n", ListSize(L));
    9.  
    10. 	ListErase(ListFind(L, 1));
    11. 	ListPrint(L);
    12.  
    13. 	ListEraseAfter(L, ListFind(L, 2));
    14. 	ListPrint(L);
    15. 	
    16. 	printf("size = %d\n", ListSize(L));
    17. 	ListModif(L, 2, 200);
    18. 	ListPrint(L);
    19.  
    20. 	ListDestory(L);
    21. 	L = NULL;
    22. }

    OK，这就是带头双向循环链表！链表的实现也就到此结束了，下面我们来对顺序表和链表做一个全面的对比！

    六、链表和顺序表的区别

    这里我们先来用单链表和顺序表对比，然后再用链表的最优结构---->带头双向循环链表来对比~！

    OK，我们再来对比一下顺序表和带头双向循环链表的区别~！

    这就是他们的区别，这里可以看出如果你需要大量查找和排序等操作时顺序表是优选，如果说是频繁的插入删除的话链表优选~！不能说他们谁好谁不好，知识应用的场景不同，他们其实是互补的数据结构~！OK，这里提到了一个东西叫缓存命中率~！这个是计算机存成原理里面的概念，这里实际上说的是存储体系和局部性原理~！OK我们大概谈谈：缓存利用率全称：CPU高速缓存利用率！

    我们一般的计算机中的三大件是：cpu、内存、和本地磁盘~！我们写的数据结构的代码都在内存中。计组中有个存储器层次体系，就是把每个存储器按快慢给分层了，我们来看看：

    这里它实际上分为四层（按照价格以及快慢）：

    寄存器和缓存实际上作用差不多，都是加载数据给cpu处理的，小的数据直接由寄存器来例如一个变量，大的数据由缓存去内存加载到cpu处理，例如数组！为什么CPU不直接到内存中去访问呢？原因很简单，CPU太快了内存和他不是一个等级，那内存以下的就更不要说了。

    为了解决这个问题电脑厂商会在CPU周围多弄几个寄存器和多级缓存；他们的速度是跟的上CPU的。这里你可能还会问既然有内存了为什么要磁盘呢？在这里有两方面的原因：一方面最直接的原因贵！另一方面是内存是带电存储而磁盘不是。内存直接能和上级交流磁盘则不行需要先加载到内存在于上级交流！

    另外还有一个是局部性原理，他分为局部性时间原理和局部性空间原理：下面是我找的一本计组上的解释：

    为什么说顺序表的缓存利用率高呢？根据局部性原理，CPU在访问万当前数据后它的下一个很有可能会被访问到，所以缓存会一次加载不止一个数据而是这个数据和后面的几个，具体几个得看硬件！这样cpu每次访问时缓存已经把顺序表的内容加载过去了，效率会高很多，原因是他们的地址是连续的！链表之所以低得原因是它的每个节点的内存地址大概率是不连续的，每一次访问一个节点的内容都要加载，而且他有可能会加载错造成缓存污染~！

    OK，好兄弟，链表就分享到这里！我们下期再见~~！

  • 相关阅读:
    聊聊流式数据湖Paimon(五)
    【毕业设计源码】PHP高校兼职跑腿系统
    【Spring Boot】如何自定义序列化以及反序列器
    使用位运算技巧比较两个数中较大的数
    Spring Boot 3.0正式发布及新特性解读
    使用 Istio CNI 支持强安全 TKE Stack 集群的服务网格流量捕获
    OpenCV入门9:图像增强和图像滤波
    zookeeper集群安装
    Oracle 快速入门
    Sentinel服务保护
  • 原文地址：https://blog.csdn.net/m0_75256358/article/details/133416026