• 学习笔记---更进一步的双向链表专题~~

    目录

    1. 双向链表的结构🦊

    2. 实现双向链表🐝

    2.1 要实现的目标🎯

    2.2 创建+初始化🦋

    2.2.1 List.h

    2.2.2 List.c

    2.2.3 test.c

    2.2.4 代码测试运行

    2.3 尾插+打印+头插🪼

    思路分析

    2.3.1 List.h

    2.3.2 List.c

    2.3.3 test.c

    2.3.4 代码测试运行

    2.4 尾删+头删🐊

    2.4.0 思路分析

    2.4.1 List.h

    2.4.2 List.c

    2.4.3 test.c

    2.4.4 代码测试运行

    2.5 查找数据+pos节点后插入+删除pos节点🦩

    2.5.0 思路分析

    2.5.1 List.h

    2.5.2 List.c

    2.5.3 test.c

    2.5.4 代码测试运行

    2.6 销毁☄️

    2.6.0思路分析

    1. 一级指针

    2.6.1 List.h

    2.6.2 List.c

    2.6.3 test.c

    2.6.4 代码测试运行

    2. 二级指针

    2.6.1 List.h

    2.6.2 List.c

    2.6.3 test.c

    2.6.4 代码测试运行

    2.7 完整代码💦

    2.7.1 List.h

    2.7.2 List.c

    2.7.3 test.c

    3. 顺序表和双向链表的分析🍻

    1. 双向链表的结构🦊

    这里的双向链表，准确的说是：带头双向循环链表

    这里的“头节点”指的是“哨兵位”，哨兵位节点不存储任何有效元素，只是站在这⾥“放哨

    的”。

    “哨兵位”存在的意义：遍历循环链表避免死循环。

    注意⚠️

    双向链表的每一个节点存储一个有效数据+下一个节点的地址+上一个节点的地址

    头节点和尾节点有些特殊：头节点指向的上一个节点的地址是尾节点，尾节点指向的下一个节点的地址是头节点

    2. 实现双向链表🐝

    2.1 要实现的目标🎯

    我们需要多个接口帮助我们实现：创建、一系列具体操作、销毁

    具体操作包括：头部/尾部插入数据、头部/尾部删除数据、打印出双向链表、指定节点之后插入数据、删除指定节点的数据、查找指定节点

    2.2 创建+初始化🦋

    2.2.1 List.h

    1. #include
    2. #include
    3. #include
    4.  
    5. typedef int LTDataType;
    6. //创建双向链表的结构体
    7. typedef struct ListNode {
    8. 	LTDataType data;
    9. 	struct ListNode* prev;
    10. 	struct ListNode* next;
    11. }ListNode;
    12.  
    13. //初始化
    14. ListNode* LTInit();//不用传入参数，直接调用接口返回一个头节点

    2.2.2 List.c

    1. #include"List.h"
    2. //初始化
    3. ListNode* LTInit()//不用传入参数，直接调用接口返回一个头节点
    4. {
    5. 	//为头节点申请空间
    6. 	ListNode* phead = (ListNode*)malloc(sizeof(ListNode));
    7. 	//判断开辟是否成功
    8. 	if (phead == NULL)
    9. 	{
    10. 		perror("malloc error!\n");
    11. 		return;
    12. 	}
    13. 	//开辟成功--->初始化头节点
    14. 	phead->data = -1;//头节点不存储有效数据，可以任意赋值
    15. 	//只有哨兵位的时候，要实现双向链表，不能指向NULL，否则无法双向循环，所以我们指向自己
    16. 	phead->prev = phead->next = phead;
    17. 	return phead;
    18. }

    2.2.3 test.c

    1. #include"List.h"
    2. void ListTest()
    3. {
    4. 	ListNode* plist = LTInit();
    5. }
    6. int main()
    7. {
    8. 	ListTest();
    9. 	return 0;
    10. }

    2.2.4 代码测试运行

    2.3 尾插+打印+头插🪼

    思路分析

    2.3.1 List.h

    1. //在双向链表中不会改变哨兵位，所以这里都可以传一级指针
    2. //尾插
    3. void LTPushBack(ListNode* phead, LTDataType x);
    4.  
    5. //打印
    6. void LTPrint(ListNode* phead);
    7.  
    8. //头插
    9. void LTPushFront(ListNode* phead, LTDataType x);

    2.3.2 List.c

    1. //在双向链表中不会改变哨兵位，所以这里都可以传一级指针
    2. // 只改变数据，不改变地址
    3.  
    4. //开辟空间
    5. ListNode* ListBuyNode(LTDataType x)
    6. {
    7. 	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
    8. 	if (node == NULL)
    9. 	{
    10. 		perror("malloc error!\n");
    11. 		return;
    12. 	}
    13. 	node->data = x;
    14. 	node->next = node->prev = NULL;
    15. 	return node;
    16. }
    17.  
    18. //尾插
    19. void LTPushBack(ListNode* phead, LTDataType x)
    20. {
    21. 	assert(phead);//注意哨兵位不能为空
    22. 	//申请空间
    23. 	ListNode* node = ListBuyNode(x);
    24. 	//先处理node的前驱指针和后继指针
    25. 	node->prev = phead->prev;
    26. 	node->next = phead;
    27. 	//再处理之前的尾节点和phead
    28. 	phead->prev->next = node;
    29. 	phead->prev = node;
    30. }
    31.  
    32. //打印
    33. void LTPrint(ListNode* phead)
    34. {
    35. 	//哨兵位不能改变
    36. 	ListNode* cur = phead->next;
    37. 	while (cur != phead)//当cur再次指向phead的时候，循环结束
    38. 	{
    39. 		printf("%d->", cur->data);
    40. 		cur = cur->next;
    41. 	}
    42. 	printf("\n");
    43. }
    44.  
    45. //头插
    46. void LTPushFront(ListNode* phead, LTDataType x)
    47. {
    48. 	assert(phead);//注意哨兵位不能为空
    49. 	//申请空间
    50. 	ListNode* node = ListBuyNode(x);
    51. 	//node插入头节点之后才算头插
    52. 	//先处理node的前驱指针和后继指针
    53. 	node->prev = phead;
    54. 	node->next = phead->next;
    55. 	//再处理phead和phead->next
    56. 	phead->next->prev = node;
    57. 	phead->next = node;
    58. }

    2.3.3 test.c

    1. #include"List.h"
    2. void ListTest()
    3. {
    4. 	ListNode* plist = LTInit();
    5. 	LTPushBack(plist, 1);
    6. 	LTPushBack(plist, 2);
    7. 	LTPushBack(plist, 3);
    8. 	LTPushBack(plist, 4);
    9. 	LTPrint(plist);//1 2 3 4 
    10. 	LTPushFront(plist, 5);
    11. 	LTPrint(plist);//5 1 2 3 4 
    12. }
    13. int main()
    14. {
    15. 	ListTest();
    16. 	return 0;
    17. }

    2.3.4 代码测试运行

    2.4 尾删+头删🐊

    2.4.0 思路分析

    2.4.1 List.h

    1. //尾删
    2. void LTPopBack(ListNode* phead);
    3.  
    4. //头删
    5. void LTPopFront(ListNode* phead);

    2.4.2 List.c

    1. //尾删
    2. void LTPopBack(ListNode* phead)
    3. {
    4. 	//不能为空链表，只有一个哨兵位不能尾删
    5. 	assert(phead&&(phead->prev!=phead||phead->next!=phead));
    6. 	ListNode* del = phead->prev;//phead->prev就是尾节点
    7. 	//先处理del
    8. 	del->prev->next = phead;
    9. 	//再处理phead
    10. 	phead->prev = del->prev;
    11. 	free(del);
    12. 	del = NULL;
    13. }
    14.  
    15. //头删
    16. void LTPopFront(ListNode* phead)
    17. {
    18. 	//不能为空链表，只有一个哨兵位不能头删
    19. 	assert(phead && (phead->prev != phead || phead->next != phead));
    20. 	ListNode* del = phead->next;
    21. 	del->next->prev = phead;
    22. 	phead->next = del->next;
    23. 	free(del);
    24. 	del = NULL;
    25. }

    2.4.3 test.c

    1. #include"List.h"
    2. void ListTest()
    3. {
    4. 	ListNode* plist = LTInit();
    5. 	LTPushBack(plist, 1);
    6. 	LTPushBack(plist, 2);
    7. 	LTPushBack(plist, 3);
    8. 	LTPushBack(plist, 4);
    9. 	LTPrint(plist);//1 2 3 4 
    10. 	LTPushFront(plist, 5);
    11. 	LTPrint(plist);//5 1 2 3 4 
    12. 	LTPopBack(plist);
    13. 	LTPrint(plist);//5 1 2 3
    14. 	LTPopFront(plist);
    15. 	LTPrint(plist);//1 2 3
    16. }
    17. int main()
    18. {
    19. 	ListTest();
    20. 	return 0;
    21. }

    2.4.4 代码测试运行

    2.5 查找数据+pos节点后插入+删除pos节点🦩

    2.5.0 思路分析

    2.5.1 List.h

    1. //查找数据
    2. ListNode* LTFind(ListNode* phead, LTDataType x);
    3.  
    4. //pos节点之后插入
    5. void LTPushAfter(ListNode* pos, LTDataType x);
    6.  
    7. //删除pos节点
    8. void LTErase(ListNode* pos);

    2.5.2 List.c

    1. //查找数据
    2. ListNode* LTFind(ListNode* phead, LTDataType x)
    3. {
    4. 	assert(phead);
    5. 	ListNode* cur = phead->next;
    6. 	while (cur!= phead)
    7. 	{
    8. 		if (cur->data == x)
    9. 		{
    10. 			return cur;
    11. 		}
    12. 		cur = cur->next;
    13. 	}
    14. 	return NULL;
    15. }
    16.  
    17. //pos节点之后插入
    18. void LTPushAfter(ListNode* pos, LTDataType x)
    19. {
    20. 	assert(pos);
    21. 	ListNode* node = ListBuyNode(x);
    22. 	//node
    23. 	node->next = pos->next;
    24. 	node->prev = pos;
    25. 	//pos
    26. 	pos->next = node;
    27. 	node->next->prev = node;
    28. }
    29.  
    30. //删除pos节点
    31. void LTErase(ListNode* pos)
    32. {
    33. 	assert(pos);
    34. 	pos->prev->next = pos->next;
    35. 	pos->next->prev = pos->prev;
    36. 	free(pos);
    37. 	pos = NULL;
    38. }

    2.5.3 test.c

    1. #include"List.h"
    2. void ListTest()
    3. {
    4. 	ListNode* plist = LTInit();
    5. 	LTPushBack(plist, 1);
    6. 	LTPushBack(plist, 2);
    7. 	LTPushBack(plist, 3);
    8. 	LTPushBack(plist, 4);
    9. 	LTPrint(plist);//1 2 3 4 
    10. 	LTPushFront(plist, 5);
    11. 	LTPrint(plist);//5 1 2 3 4 
    12. 	LTPopBack(plist);
    13. 	LTPrint(plist);//5 1 2 3
    14. 	LTPopFront(plist);
    15. 	LTPrint(plist);//1 2 3
    16. 	ListNode* find = LTFind(plist, 1);
    17. 	/*LTPushAfter(find, 4);*/	
    18. 	//LTPrint(plist);//1 4 2 3
    19. 	LTErase(find);
    20. 	LTPrint(plist);//2 3
    21.  
    22. }
    23. int main()
    24. {
    25. 	ListTest();
    26. 	return 0;
    27. }

    2.5.4 代码测试运行

    2.6 销毁☄️

    2.6.0思路分析

    一开始的初始化，我们直接调用了接口，返回头节点进行初始化。我们没有考虑一级指针还是二级指针的问题。

    那么，最后的销毁又该怎么办？是一级指针？还是二级指针？下面我们一一来尝试

    1. 一级指针

    2.6.1 List.h
    1. //销毁
    2. void LTDestroy(ListNode* phead);
    2.6.2 List.c
    1. //销毁
    2. void LTDestroy(ListNode* phead)
    3. {
    4. 	assert(phead);
    5. 	ListNode* cur = phead->next;
    6. 	while(cur!=phead)
    7. 	{
    8. 		ListNode* next = cur->next;
    9. 		free(cur);
    10. 		cur = next;
    11. 	}
    12. 	//注意哨兵位还没有释放
    13. 	free(phead);
    14. 	phead = NULL;
    15. }
    2.6.3 test.c
    1. #include"List.h"
    2. void ListTest()
    3. {
    4. 	ListNode* plist = LTInit();
    5. 	LTPushBack(plist, 1);
    6. 	LTPushBack(plist, 2);
    7. 	LTPushBack(plist, 3);
    8. 	LTPushBack(plist, 4);
    9. 	LTPrint(plist);//1 2 3 4 
    10. 	//LTPushFront(plist, 5);
    11. 	//LTPrint(plist);//5 1 2 3 4 
    12. 	//LTPopBack(plist);
    13. 	//LTPrint(plist);//5 1 2 3
    14. 	//LTPopFront(plist);
    15. 	//LTPrint(plist);//1 2 3
    16. 	//ListNode* find = LTFind(plist, 1);
    17. 	/*LTPushAfter(find, 4);*/	
    18. 	LTPrint(plist);//1 4 2 3
    19. 	//LTErase(find);
    20. 	//LTPrint(plist);//2 3
    21. 	LTDestroy(plist);
    22.  
    23. }
    24. int main()
    25. {
    26. 	ListTest();
    27. 	return 0;
    28. }
    2.6.4 代码测试运行

    一级指针：
    phead的改变不影响plist，phead释放之后，plist指向已经释放掉的空间——>把plist置为空

    那么置为空之前，还要不要将plist指向的空间再free一次？

    我们尝试一下

    那么再思考一下：一级指针是会导致phead的改变不影响plist，那么plist是什么没有改变？是指plist保存的值没有被改变还是plist的这块空间的地址没有被释放？

    这里报错指的是plist指向无效地址

    注意⚠️
    如果plist的地址没有被释放，那么直接free（plist）是不会报错的

    所以在一级指针的情况下：plist的地址已经被释放了，没有被置为空的可以理解是plist的地址名称

    2.6.5 一级指针的改进---test.c

    2. 二级指针

    2.6.1 List.h
    1. //销毁
    2. //void LTDestroy(ListNode* phead);
    3. void LTDestroy(ListNode** phead);
    2.6.2 List.c
    1. //销毁
    2. void LTDestroy(ListNode** phead)
    3. {
    4. 	assert(phead && *phead);
    5. 	ListNode* cur = (*phead)->next;
    6. 	while (cur != *phead)
    7. 	{
    8. 		ListNode* next = cur->next;
    9. 		free(cur);
    10. 		cur = next;
    11. 	}
    12. 	free(*phead);
    13. 	*phead = NULL;
    14. }
    2.6.3 test.c
    1. #include"List.h"
    2. void ListTest()
    3. {
    4. 	ListNode* plist = LTInit();
    5. 	LTPushBack(plist, 1);
    6. 	LTPushBack(plist, 2);
    7. 	LTPushBack(plist, 3);
    8. 	LTPushBack(plist, 4);
    9. 	LTPrint(plist);//1 2 3 4 
    10. 	//LTPushFront(plist, 5);
    11. 	//LTPrint(plist);//5 1 2 3 4 
    12. 	//LTPopBack(plist);
    13. 	//LTPrint(plist);//5 1 2 3
    14. 	//LTPopFront(plist);
    15. 	//LTPrint(plist);//1 2 3
    16. 	//ListNode* find = LTFind(plist, 1);
    17. 	///*LTPushAfter(find, 4);*/	
    18. 	LTPrint(plist);//1 4 2 3
    19. 	//LTErase(find);
    20. 	//LTPrint(plist);//2 3
    21. 	//LTDestroy(plist);
    22. 	//plist = NULL;
    23. 	LTDestroy(&plist);
    24. }
    25. int main()
    26. {
    27. 	ListTest();
    28. 	return 0;
    29. }
    2.6.4 代码测试运行

    虽然，二级指针不用手动将plist置为空
    但是，更推荐一级指针，因为其他接口基本上都是一级指针——>保持接口的一致性

    2.7 完整代码💦

    2.7.1 List.h

    1. #pragma once
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7.  
    8. typedef int LTDataType;
    9. //创建双向链表的结构体
    10. typedef struct ListNode {
    11. 	LTDataType data;
    12. 	struct ListNode* prev;
    13. 	struct ListNode* next;
    14. }ListNode;
    15.  
    16. //初始化
    17. ListNode* LTInit();//不用传入参数，直接调用接口返回一个头节点
    18.  
    19. //在双向链表中不会改变哨兵位，所以这里都可以传一级指针
    20. //尾插
    21. void LTPushBack(ListNode* phead, LTDataType x);
    22.  
    23. //打印
    24. void LTPrint(ListNode* phead);
    25.  
    26. //头插
    27. void LTPushFront(ListNode* phead, LTDataType x);
    28.  
    29. //尾删
    30. void LTPopBack(ListNode* phead);
    31.  
    32. //头删
    33. void LTPopFront(ListNode* phead);
    34.  
    35. //查找数据
    36. ListNode* LTFind(ListNode* phead, LTDataType x);
    37.  
    38. //pos节点之后插入
    39. void LTPushAfter(ListNode* pos, LTDataType x);
    40.  
    41. //删除pos节点
    42. void LTErase(ListNode* pos);
    43.  
    44. //销毁
    45. void LTDestroy(ListNode* phead);

    2.7.2 List.c

    1. #include"List.h"
    2. //初始化
    3. ListNode* LTInit()//不用传入参数，直接调用接口返回一个头节点
    4. {
    5. 	//为头节点申请空间
    6. 	ListNode* phead = (ListNode*)malloc(sizeof(ListNode));
    7. 	//判断开辟是否成功
    8. 	if (phead == NULL)
    9. 	{
    10. 		perror("malloc error!\n");
    11. 		return;
    12. 	}
    13. 	//开辟成功--->初始化头节点
    14. 	phead->data = -1;//头节点不存储有效数据，可以任意赋值
    15. 	//只有哨兵位的时候，要实现双向链表，不能指向NULL，否则无法双向循环，所以我们指向自己
    16. 	phead->prev = phead->next = phead;
    17. 	return phead;
    18. }
    19.  
    20. //在双向链表中不会改变哨兵位，所以这里都可以传一级指针
    21. // 只改变数据，不改变地址
    22.  
    23. //开辟空间
    24. ListNode* ListBuyNode(LTDataType x)
    25. {
    26. 	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
    27. 	if (node == NULL)
    28. 	{
    29. 		perror("malloc error!\n");
    30. 		return;
    31. 	}
    32. 	node->data = x;
    33. 	node->next = node->prev = NULL;
    34. 	return node;
    35. }
    36.  
    37. //尾插
    38. void LTPushBack(ListNode* phead, LTDataType x)
    39. {
    40. 	assert(phead);//注意哨兵位不能为空
    41. 	//申请空间
    42. 	ListNode* node = ListBuyNode(x);
    43. 	//先处理node的前驱指针和后继指针
    44. 	node->prev = phead->prev;
    45. 	node->next = phead;
    46. 	//再处理之前的尾节点和phead
    47. 	phead->prev->next = node;
    48. 	phead->prev = node;
    49. }
    50.  
    51. //打印
    52. void LTPrint(ListNode* phead)
    53. {
    54. 	//哨兵位不能改变
    55. 	ListNode* cur = phead->next;
    56. 	while (cur != phead)//当cur再次指向phead的时候，循环结束
    57. 	{
    58. 		printf("%d->", cur->data);
    59. 		cur = cur->next;
    60. 	}
    61. 	printf("\n");
    62. }
    63.  
    64. //头插
    65. void LTPushFront(ListNode* phead, LTDataType x)
    66. {
    67. 	assert(phead);//注意哨兵位不能为空
    68. 	//申请空间
    69. 	ListNode* node = ListBuyNode(x);
    70. 	//node插入头节点之后才算头插
    71. 	//先处理node的前驱指针和后继指针
    72. 	node->prev = phead;
    73. 	node->next = phead->next;
    74. 	//再处理phead和phead->next
    75. 	phead->next->prev = node;
    76. 	phead->next = node;
    77. }
    78.  
    79. //尾删
    80. void LTPopBack(ListNode* phead)
    81. {
    82. 	//不能为空链表，只有一个哨兵位不能尾删
    83. 	assert(phead&&(phead->prev!=phead||phead->next!=phead));
    84. 	ListNode* del = phead->prev;//phead->prev就是尾节点
    85. 	//先处理del
    86. 	del->prev->next = phead;
    87. 	//再处理phead
    88. 	phead->prev = del->prev;
    89. 	free(del);
    90. 	del = NULL;
    91. }
    92.  
    93. //头删
    94. void LTPopFront(ListNode* phead)
    95. {
    96. 	//不能为空链表，只有一个哨兵位不能头删
    97. 	assert(phead && (phead->prev != phead || phead->next != phead));
    98. 	ListNode* del = phead->next;
    99. 	del->next->prev = phead;
    100. 	phead->next = del->next;
    101. 	free(del);
    102. 	del = NULL;
    103. }
    104.  
    105. //查找数据
    106. ListNode* LTFind(ListNode* phead, LTDataType x)
    107. {
    108. 	assert(phead);
    109. 	ListNode* cur = phead->next;
    110. 	while (cur != phead)
    111. 	{
    112. 		if (cur->data == x)
    113. 		{
    114. 			return cur;
    115. 		}
    116. 		cur = cur->next;
    117. 	}
    118. 	return NULL;
    119. }
    120.  
    121. //pos节点之后插入
    122. void LTPushAfter(ListNode* pos, LTDataType x)
    123. {
    124. 	assert(pos);
    125. 	ListNode* node = ListBuyNode(x);
    126. 	//node
    127. 	node->next = pos->next;
    128. 	node->prev = pos;
    129. 	//pos
    130. 	pos->next = node;
    131. 	node->next->prev = node;
    132. }
    133.  
    134. //删除pos节点
    135. void LTErase(ListNode* pos)
    136. {
    137. 	assert(pos);
    138. 	pos->prev->next = pos->next;
    139. 	pos->next->prev = pos->prev;
    140. 	free(pos);
    141. 	pos = NULL;
    142. }
    143.  
    144. //销毁
    145. void LTDestroy(ListNode* phead)
    146. {
    147. 	assert(phead);
    148. 	ListNode* cur = phead->next;
    149. 	while(cur!=phead)
    150. 	{
    151. 		ListNode* next = cur->next;
    152. 		free(cur);
    153. 		cur = next;
    154. 	}
    155. 	//注意哨兵位还没有释放
    156. 	free(phead);
    157. 	phead = NULL;
    158. }

    2.7.3 test.c

    1. #include"List.h"
    2. void ListTest()
    3. {
    4. 	ListNode* plist = LTInit();
    5. 	LTPushBack(plist, 1);
    6. 	LTPushBack(plist, 2);
    7. 	LTPushBack(plist, 3);
    8. 	LTPushBack(plist, 4);
    9. 	LTPrint(plist);//1 2 3 4 
    10. 	LTPushFront(plist, 5);
    11. 	LTPrint(plist);//5 1 2 3 4 
    12. 	LTPopBack(plist);
    13. 	LTPrint(plist);//5 1 2 3
    14. 	LTPopFront(plist);
    15. 	LTPrint(plist);//1 2 3
    16. 	ListNode* find = LTFind(plist, 1);
    17. 	/*LTPushAfter(find, 4);*/	
    18. 	//LTPrint(plist);//1 4 2 3
    19. 	LTErase(find);
    20. 	LTPrint(plist);//2 3
    21. 	LTDestroy(plist);
    22. 	plist = NULL;
    23. }
    24. int main()
    25. {
    26. 	ListTest();
    27. 	return 0;
    28. }

    3. 顺序表和双向链表的分析🍻

    不同点顺序表链表（单链表）
    存储空间上物理上一定连续逻辑上连续，但物理上不一定连续
    随机访问支持O（1）不支持：O（N）
    任意位置插入或者删除元素看你需要搬移元素，效率低O（N）只需要改变指针指向
    插入动态顺序表，空间不够的时候需要扩容没有容量的概念
    应用场景元素高效存储+频繁访问任意位置插入和删除频繁

    本次的分享到这里就结束了！！！

    PS：小江目前只是个新手小白。欢迎大家在评论区讨论哦！有问题也可以讨论的！

    如果对你有帮助的话，记得点赞👍+收藏⭐️+关注➕

  • 相关阅读:
    Fiddler/Charles - 夜神模拟器证书安装App抓包
    oracle 还原被覆盖的视图
    libhdfs(hdfs c 接口)配置记录
    leetcode Top100(12)最大子数组和
    论文写作 - CCF会议论文常用表述
    二百零一、Flink——Flink配置状态后端运行后报错：Can not create a Path from an empty string
    LeetCode每日一题(2201. Count Artifacts That Can Be Extracted)
    51单片机实现换能器超声波测水深
    036、目标检测-锚框
    Linux下远程连接MySQL数据库的方法
  • 原文地址：https://blog.csdn.net/2301_79184587/article/details/134088077