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

【海贼王的数据航海：利用数据结构成为数据海洋的霸主】链表—单链表

作者：小蓝xlanll | 2024-03-06 01:04:30

赞

踩

【海贼王的数据航海：利用数据结构成为数据海洋的霸主】链表—单链表

目录

1 -> 链表

1.1 -> 链表的概念及结构

1.2 -> 链表的分类

2 -> 无头+单向+非循环链表(单链表)

2.1 -> 接口声明

2.2 -> 接口实现

2.2.1 -> 动态申请一个结点

2.2.2 -> 单链表的打印

2.2.3 -> 单链表的尾插

2.2.4 -> 单链表的头插

2.2.5 -> 单链表的尾删

2.2.6 -> 单链表的头删

2.2.7 -> 单链表的查找

2.2.8 -> 单链表在pos位置之前插入x

2.2.9 -> 单链表在pos位置之后插入x

2.2.10 -> 单链表删除pos位置的值

2.2.11 -> 单链表删除pos位置之后的值

2.3 -> 完整代码

2.3.1 -> SList.h

2.3.2 -> SList.c

2.3.3 -> Test.c

1 -> 链表

1.1 -> 链表的概念及结构

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

现实中 数据结构中

 注意：

  1. 上图可看出，链式结构在逻辑上是连续的，但是在物理上不一定连续；
  2. 现实中的结点一般都是从堆上申请出来的；
  3. 从堆上申请的空间，是按照一定策略分配的，两次申请的空间可能连续，也可能不连续。

假设在32位系统上，结点中值域为int类型，则一个节点的大小为8个字节，则也可能有以下链表：

1.2 -> 链表的分类

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

1. 单向或双向

2. 带头或不带头

3. 循环或非循环

虽然有很多链表结构，但最常用的还是这两种：

1. 无头单向非循环链表

2. 带头双向循环链表

1. 无头单向非循环链表：结构简单，一般不会单独用来存储数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等。

2. 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了。

2 -> 无头+单向+非循环链表(单链表)

2.1 -> 接口声明

  1. #pragma once
  2.  
  3. #define _CRT_SECURE_NO_WARNINGS 1
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <assert.h>
  7.  
  8. // 无头+单向+非循环链表增删查改实现
  9. typedef int SLTDateType;
  10.  
  11. typedef struct SLTNode
  12. {
  13. 	SLTDateType data;
  14. 	struct SLTNode* next;
  15. }SLTNode;
  16.  
  17. // 动态申请一个结点
  18. SLTNode* BuySLTNode(SLTDateType x);
  19.  
  20. // 单链表打印
  21. void SLTPrint(SLTNode* phead);
  22.  
  23. // 单链表尾插
  24. void SLTPushBack(SLTNode** pphead, SLTDateType x);
  25.  
  26. // 单链表的头插
  27. void SLTPushFront(SLTNode** pphead, SLTDateType x);
  28.  
  29. // 单链表的尾删
  30. void SLTPopBack(SLTNode** pphead);
  31.  
  32. // 单链表头删
  33. void SLTPopFront(SLTNode** pphead);
  34.  
  35. // 单链表查找
  36. SLTNode* SLTFind(SLTNode* phead, SLTDateType x);
  37.  
  38. // 单链表在pos位置之前插入x
  39. void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDateType x);
  40.  
  41. // 单链表在pos位置之后插入x
  42. void SLTInsertAfter(SLTNode* pos, SLTDateType x);
  43.  
  44. // 单链表删除pos位置的值
  45. void SLTErase(SLTNode** pphead, SLTNode* pos);
  46.  
  47. // 单链表删除pos位置之后的值
  48. void SLTEraseAfter(SLTNode* pos);

2.2 -> 接口实现

2.2.1 -> 动态申请一个结点

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

2.2.2 -> 单链表的打印

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

2.2.3 -> 单链表的尾插

  1. // 单链表的尾插
  2. void SLTPushBack(SLTNode** pphead, SLTDateType x)
  3. {
  4. 	assert(pphead);
  5. 	SLTNode* newnode = BuySLTNode(x);
  6. 	if (*pphead == NULL)
  7. 	{
  8. 		 *pphead = newnode;
  9. 	}
  10. 	else
  11. 	{
  12. 		SLTNode* cur = *pphead;
  13. 		while (cur->next != NULL)
  14. 		{
  15. 			cur = cur->next;
  16. 		}
  17. 		cur->next = newnode;
  18. 	}
  19. }
  1. // 尾插测试
  2. void SLTTest1()
  3. {
  4. 	SLTNode* plist = NULL;
  5.  
  6. 	SLTPushBack(&plist, 1);
  7. 	SLTPushBack(&plist, 2);
  8. 	SLTPushBack(&plist, 3);
  9. 	SLTPushBack(&plist, 4);
  10.  
  11. 	SLTPrint(plist);
  12. }

2.2.4 -> 单链表的头插

  1. // 单链表的头插
  2. void SLTPushFront(SLTNode** pphead, SLTDateType x)
  3. {
  4. 	assert(pphead);
  5. 	SLTNode* newnode = BuySLTNode(x);
  6.  
  7. 	newnode->next = *pphead;
  8. 	*pphead = newnode;
  9. }
  1. // 头插测试
  2. void SLTTest2()
  3. {
  4. 	SLTNode* plist = NULL;
  5.  
  6. 	SLTPushFront(&plist, 1);
  7. 	SLTPushFront(&plist, 2);
  8. 	SLTPushFront(&plist, 3);
  9. 	SLTPushFront(&plist, 4);
  10.  
  11. 	SLTPrint(plist);
  12. }

2.2.5 -> 单链表的尾删

  1. // 单链表的尾删
  2. void SLTPopBack(SLTNode** pphead)
  3. {
  4. 	assert(pphead);
  5. 	assert(*pphead); // 暴力检查
  6.  
  7. 	 温柔的检查
  8. 	//if (*pphead == NULL)
  9. 	//{
  10. 	//	return;
  11. 	//}
  12.  
  13. 	// 只有一个节点
  14. 	if ((*pphead)->next == NULL)
  15. 	{
  16. 		free(*pphead);
  17. 		*pphead = NULL;
  18. 	}
  19. 	// 有多个节点
  20. 	else
  21. 	{
  22. 		SLTNode* prev = *pphead;
  23. 		SLTNode* tail = *pphead;
  24. 		while (tail->next != NULL)
  25. 		{
  26. 			prev = tail;
  27. 			tail = tail->next;
  28. 		}
  29.  
  30. 		free(tail);
  31. 		tail = NULL;
  32.  
  33. 		prev->next = NULL;
  34. 	}
  35. }
  1. // 尾删测试
  2. void SLTTest3()
  3. {
  4. 	SLTNode* plist = NULL;
  5.  
  6. 	SLTPushBack(&plist, 1);
  7. 	SLTPushBack(&plist, 2);
  8. 	SLTPushBack(&plist, 3);
  9. 	SLTPushBack(&plist, 4);
  10. 	SLTPrint(plist);
  11.  
  12. 	SLTPopBack(&plist);
  13. 	SLTPrint(plist);
  14. 	SLTPopBack(&plist);
  15. 	SLTPrint(plist);
  16. 	SLTPopBack(&plist);
  17. 	SLTPrint(plist);
  18. 	SLTPopBack(&plist);
  19. 	SLTPrint(plist);
  20. }

2.2.6 -> 单链表的头删

  1. // 单链表的头删
  2. void SLTPopFront(SLTNode** pphead)
  3. {
  4. 	assert(*pphead);
  5. 	SLTNode* tail = *pphead;
  6.  
  7. 	*pphead = (*pphead)->next;
  8. 	free(tail);
  9. 	tail = NULL;
  10. }
  1. // 头删测试
  2. void SLTTest4()
  3. {
  4. 	SLTNode* plist = NULL;
  5.  
  6. 	SLTPushBack(&plist, 1);
  7. 	SLTPushBack(&plist, 2);
  8. 	SLTPushBack(&plist, 3);
  9. 	SLTPushBack(&plist, 4);
  10. 	SLTPrint(plist);
  11.  
  12. 	SLTPopFront(&plist);
  13. 	SLTPrint(plist);
  14. 	SLTPopFront(&plist);
  15. 	SLTPrint(plist);
  16. 	SLTPopFront(&plist);
  17. 	SLTPrint(plist);
  18. 	SLTPopFront(&plist);
  19. 	SLTPrint(plist);
  20. }

2.2.7 -> 单链表的查找

  1. // 单链表的查找
  2. SLTNode* SLTFind(SLTNode* phead, SLTDateType x)
  3. {
  4. 	SLTNode* ptr = phead;
  5. 	while (ptr->next != NULL)
  6. 	{
  7. 		if (ptr->data == x)
  8. 		{
  9. 			return ptr;
  10. 		}
  11. 		else
  12. 		{
  13. 			ptr = ptr->next;
  14. 		}
  15. 	}
  16.  
  17. 	return NULL;
  18. }
  1. // 查找测试
  2. void SLTTest5()
  3. {
  4. 	SLTNode* plist = NULL;
  5.  
  6. 	SLTPushBack(&plist, 1);
  7. 	SLTPushBack(&plist, 2);
  8. 	SLTPushBack(&plist, 3);
  9. 	SLTPushBack(&plist, 4);
  10. 	SLTPrint(plist);
  11.  
  12. 	SLTNode* ans = SLTFind(plist, 1);
  13. 	if (ans)
  14. 		ans->data = 10;
  15. 	SLTPrint(plist);
  16. }

2.2.8 -> 单链表在pos位置之前插入x

  1. // 单链表在pos位置之前插入x
  2. void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDateType x)
  3. {
  4. 	assert(pphead);
  5. 	assert(pos);
  6. 	if (pos == *pphead)
  7. 	{
  8. 		SLTPushFront(pphead, x);
  9. 	}
  10. 	else
  11. 	{
  12. 		SLTNode* newnode = BuySLTNode(x);
  13. 		SLTNode* prev = *pphead;
  14. 		while (prev->next != pos)
  15. 		{
  16. 			prev = prev->next;
  17. 		}
  18.  
  19. 		prev->next = newnode;
  20. 		newnode->next = pos;
  21. 	}
  22. }
  1. // 在pos位置之前插入x测试
  2. void SLTTest6()
  3. {
  4. 	SLTNode* plist = NULL;
  5.  
  6. 	SLTPushBack(&plist, 1);
  7. 	SLTPushBack(&plist, 2);
  8. 	SLTPushBack(&plist, 3);
  9. 	SLTPushBack(&plist, 4);
  10. 	SLTPrint(plist);
  11.  
  12. 	SLTNode* pos = SLTFind(plist, 2);
  13. 	if (pos)
  14. 		SLTInsert(&plist, pos, 99);
  15. 	SLTPrint(plist);
  16. }

2.2.9 -> 单链表在pos位置之后插入x

  1. // 单链表在pos位置之后插入x
  2. void SLTInsertAfter(SLTNode* pos, SLTDateType x)
  3. {
  4. 	assert(pos);
  5. 	SLTNode* newnode = BuySLTNode(x);
  6. 	SLTNode* tmp = pos->next;
  7.  
  8. 	pos->next = newnode;
  9. 	newnode->next = tmp;
  10. }
  1. // 在pos位置之后插入x测试
  2. void SLTTest7()
  3. {
  4. 	SLTNode* plist = NULL;
  5.  
  6. 	SLTPushBack(&plist, 1);
  7. 	SLTPushBack(&plist, 2);
  8. 	SLTPushBack(&plist, 3);
  9. 	SLTPushBack(&plist, 4);
  10. 	SLTPrint(plist);
  11.  
  12. 	SLTNode* pos = SLTFind(plist, 2);
  13. 	if (pos)
  14. 		SLTInsertAfter(pos, 99);
  15. 	SLTPrint(plist);
  16. }

2.2.10 -> 单链表删除pos位置的值

  1. // 单链表删除pos位置的值
  2. void SLTErase(SLTNode** pphead, SLTNode* pos)
  3. {
  4. 	assert(pphead);
  5. 	assert(*pphead);
  6. 	assert(pos);
  7. 	if (pos == *pphead)
  8. 	{
  9. 		SLTPopFront(pphead);
  10. 	}
  11. 	else
  12. 	{
  13. 		SLTNode* prev = *pphead;
  14. 		if (prev->next != pos)
  15. 		{
  16. 			prev = prev->next;
  17. 		}
  18.  
  19. 		prev->next = pos->next;
  20. 		free(pos);
  21. 		pos = NULL;
  22. 	}
  23. }
  1. // 删除pos位置的值测试
  2. void SLTTest8()
  3. {
  4. 	SLTNode* plist = NULL;
  5.  
  6. 	SLTPushBack(&plist, 1);
  7. 	SLTPushBack(&plist, 2);
  8. 	SLTPushBack(&plist, 3);
  9. 	SLTPushBack(&plist, 4);
  10. 	SLTPrint(plist);
  11.  
  12. 	SLTNode* pos = SLTFind(plist, 2);
  13. 	if (pos)
  14. 		SLTErase(&plist, pos);
  15. 	SLTPrint(plist);
  16. }

2.2.11 -> 单链表删除pos位置之后的值

  1. // 单链表删除pos位置之后的值
  2. void SLTEraseAfter(SLTNode* pos)
  3. {
  4. 	assert(pos);
  5. 	assert(pos->next);
  6. 	SLTNode* tmp = pos->next->next;
  7.  
  8. 	free(pos->next);
  9. 	pos->next = tmp;
  10. }
  1. // 删除pos位置之后的值测试
  2. void SLTTest9()
  3. {
  4. 	SLTNode* plist = NULL;
  5.  
  6. 	SLTPushBack(&plist, 1);
  7. 	SLTPushBack(&plist, 2);
  8. 	SLTPushBack(&plist, 3);
  9. 	SLTPushBack(&plist, 4);
  10. 	SLTPrint(plist);
  11.  
  12. 	SLTNode* pos = SLTFind(plist, 2);
  13. 	if (pos)
  14. 		SLTEraseAfter(pos);
  15. 	SLTPrint(plist);
  16. }

2.3 -> 完整代码

2.3.1 -> SList.h

  1. #pragma once
  2.  
  3. #define _CRT_SECURE_NO_WARNINGS 1
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <assert.h>
  7.  
  8. // 无头+单向+非循环链表增删查改实现
  9. typedef int SLTDateType;
  10.  
  11. typedef struct SLTNode
  12. {
  13. 	SLTDateType data;
  14. 	struct SLTNode* next;
  15. }SLTNode;
  16.  
  17. // 动态申请一个结点
  18. SLTNode* BuySLTNode(SLTDateType x);
  19.  
  20. // 单链表打印
  21. void SLTPrint(SLTNode* phead);
  22.  
  23. // 单链表尾插
  24. void SLTPushBack(SLTNode** pphead, SLTDateType x);
  25.  
  26. // 单链表的头插
  27. void SLTPushFront(SLTNode** pphead, SLTDateType x);
  28.  
  29. // 单链表的尾删
  30. void SLTPopBack(SLTNode** pphead);
  31.  
  32. // 单链表头删
  33. void SLTPopFront(SLTNode** pphead);
  34.  
  35. // 单链表查找
  36. SLTNode* SLTFind(SLTNode* phead, SLTDateType x);
  37.  
  38. // 单链表在pos位置之前插入x
  39. void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDateType x);
  40.  
  41. // 单链表在pos位置之后插入x
  42. void SLTInsertAfter(SLTNode* pos, SLTDateType x);
  43.  
  44. // 单链表删除pos位置的值
  45. void SLTErase(SLTNode** pphead, SLTNode* pos);
  46.  
  47. // 单链表删除pos位置之后的值
  48. void SLTEraseAfter(SLTNode* pos);

2.3.2 -> SList.c

  1. #include "SList.h"
  2.  
  3. // 动态申请一个结点
  4. SLTNode* BuySLTNode(SLTDateType x)
  5. {
  6. 	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
  7. 	if (newnode == NULL)
  8. 	{
  9. 		perror("malloc fail");
  10. 		return NULL;
  11. 	}
  12.  
  13. 	newnode->data = x;
  14. 	newnode->next = NULL;
  15.  
  16. 	return newnode;
  17. }
  18.  
  19. // 单链表的打印
  20. void SLTPrint(SLTNode* phead)
  21. {
  22. 	SLTNode* cur = phead;
  23. 	while (cur != NULL)
  24. 	{
  25. 		printf("%d->", cur->data);
  26. 		cur = cur->next;
  27. 	}
  28.  
  29. 	printf("NULL\n");
  30. }
  31.  
  32. // 单链表的尾插
  33. void SLTPushBack(SLTNode** pphead, SLTDateType x)
  34. {
  35. 	assert(pphead);
  36. 	SLTNode* newnode = BuySLTNode(x);
  37. 	if (*pphead == NULL)
  38. 	{
  39. 		 *pphead = newnode;
  40. 	}
  41. 	else
  42. 	{
  43. 		SLTNode* cur = *pphead;
  44. 		while (cur->next != NULL)
  45. 		{
  46. 			cur = cur->next;
  47. 		}
  48. 		cur->next = newnode;
  49. 	}
  50. }
  51.  
  52. // 单链表的头插
  53. void SLTPushFront(SLTNode** pphead, SLTDateType x)
  54. {
  55. 	assert(pphead);
  56. 	SLTNode* newnode = BuySLTNode(x);
  57.  
  58. 	newnode->next = *pphead;
  59. 	*pphead = newnode;
  60. }
  61.  
  62. // 单链表的尾删
  63. void SLTPopBack(SLTNode** pphead)
  64. {
  65. 	assert(pphead);
  66. 	assert(*pphead); // 暴力检查
  67.  
  68. 	 温柔的检查
  69. 	//if (*pphead == NULL)
  70. 	//{
  71. 	//	return;
  72. 	//}
  73.  
  74. 	// 只有一个节点
  75. 	if ((*pphead)->next == NULL)
  76. 	{
  77. 		free(*pphead);
  78. 		*pphead = NULL;
  79. 	}
  80. 	// 有多个节点
  81. 	else
  82. 	{
  83. 		SLTNode* prev = *pphead;
  84. 		SLTNode* tail = *pphead;
  85. 		while (tail->next != NULL)
  86. 		{
  87. 			prev = tail;
  88. 			tail = tail->next;
  89. 		}
  90.  
  91. 		free(tail);
  92. 		tail = NULL;
  93.  
  94. 		prev->next = NULL;
  95. 	}
  96. }
  97.  
  98. // 单链表的头删
  99. void SLTPopFront(SLTNode** pphead)
  100. {
  101. 	assert(*pphead);
  102. 	SLTNode* tail = *pphead;
  103.  
  104. 	*pphead = (*pphead)->next;
  105. 	free(tail);
  106. 	tail = NULL;
  107. }
  108.  
  109. // 单链表的查找
  110. SLTNode* SLTFind(SLTNode* phead, SLTDateType x)
  111. {
  112. 	SLTNode* ptr = phead;
  113. 	while (ptr->next != NULL)
  114. 	{
  115. 		if (ptr->data == x)
  116. 		{
  117. 			return ptr;
  118. 		}
  119. 		else
  120. 		{
  121. 			ptr = ptr->next;
  122. 		}
  123. 	}
  124.  
  125. 	return NULL;
  126. }
  127.  
  128. // 单链表在pos位置之前插入x
  129. void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDateType x)
  130. {
  131. 	assert(pphead);
  132. 	assert(pos);
  133. 	if (pos == *pphead)
  134. 	{
  135. 		SLTPushFront(pphead, x);
  136. 	}
  137. 	else
  138. 	{
  139. 		SLTNode* newnode = BuySLTNode(x);
  140. 		SLTNode* prev = *pphead;
  141. 		while (prev->next != pos)
  142. 		{
  143. 			prev = prev->next;
  144. 		}
  145.  
  146. 		prev->next = newnode;
  147. 		newnode->next = pos;
  148. 	}
  149. }
  150.  
  151. // 单链表在pos位置之后插入x
  152. void SLTInsertAfter(SLTNode* pos, SLTDateType x)
  153. {
  154. 	assert(pos);
  155. 	SLTNode* newnode = BuySLTNode(x);
  156. 	SLTNode* tmp = pos->next;
  157.  
  158. 	pos->next = newnode;
  159. 	newnode->next = tmp;
  160. }
  161.  
  162. // 单链表删除pos位置的值
  163. void SLTErase(SLTNode** pphead, SLTNode* pos)
  164. {
  165. 	assert(pphead);
  166. 	assert(*pphead);
  167. 	assert(pos);
  168. 	if (pos == *pphead)
  169. 	{
  170. 		SLTPopFront(pphead);
  171. 	}
  172. 	else
  173. 	{
  174. 		SLTNode* prev = *pphead;
  175. 		if (prev->next != pos)
  176. 		{
  177. 			prev = prev->next;
  178. 		}
  179.  
  180. 		prev->next = pos->next;
  181. 		free(pos);
  182. 		pos = NULL;
  183. 	}
  184. }
  185.  
  186. // 单链表删除pos位置之后的值
  187. void SLTEraseAfter(SLTNode* pos)
  188. {
  189. 	assert(pos);
  190. 	assert(pos->next);
  191. 	SLTNode* tmp = pos->next->next;
  192.  
  193. 	free(pos->next);
  194. 	pos->next = tmp;
  195. }

2.3.3 -> Test.c

  1. #include "SList.h"
  2.  
  3. // 尾插测试
  4. void SLTTest1()
  5. {
  6. 	SLTNode* plist = NULL;
  7.  
  8. 	SLTPushBack(&plist, 1);
  9. 	SLTPushBack(&plist, 2);
  10. 	SLTPushBack(&plist, 3);
  11. 	SLTPushBack(&plist, 4);
  12.  
  13. 	SLTPrint(plist);
  14. }
  15.  
  16. // 头插测试
  17. void SLTTest2()
  18. {
  19. 	SLTNode* plist = NULL;
  20.  
  21. 	SLTPushFront(&plist, 1);
  22. 	SLTPushFront(&plist, 2);
  23. 	SLTPushFront(&plist, 3);
  24. 	SLTPushFront(&plist, 4);
  25.  
  26. 	SLTPrint(plist);
  27. }
  28.  
  29. // 尾删测试
  30. void SLTTest3()
  31. {
  32. 	SLTNode* plist = NULL;
  33.  
  34. 	SLTPushBack(&plist, 1);
  35. 	SLTPushBack(&plist, 2);
  36. 	SLTPushBack(&plist, 3);
  37. 	SLTPushBack(&plist, 4);
  38. 	SLTPrint(plist);
  39.  
  40. 	SLTPopBack(&plist);
  41. 	SLTPrint(plist);
  42. 	SLTPopBack(&plist);
  43. 	SLTPrint(plist);
  44. 	SLTPopBack(&plist);
  45. 	SLTPrint(plist);
  46. 	SLTPopBack(&plist);
  47. 	SLTPrint(plist);
  48. }
  49.  
  50. // 头删测试
  51. void SLTTest4()
  52. {
  53. 	SLTNode* plist = NULL;
  54.  
  55. 	SLTPushBack(&plist, 1);
  56. 	SLTPushBack(&plist, 2);
  57. 	SLTPushBack(&plist, 3);
  58. 	SLTPushBack(&plist, 4);
  59. 	SLTPrint(plist);
  60.  
  61. 	SLTPopFront(&plist);
  62. 	SLTPrint(plist);
  63. 	SLTPopFront(&plist);
  64. 	SLTPrint(plist);
  65. 	SLTPopFront(&plist);
  66. 	SLTPrint(plist);
  67. 	SLTPopFront(&plist);
  68. 	SLTPrint(plist);
  69. }
  70.  
  71. // 查找测试
  72. void SLTTest5()
  73. {
  74. 	SLTNode* plist = NULL;
  75.  
  76. 	SLTPushBack(&plist, 1);
  77. 	SLTPushBack(&plist, 2);
  78. 	SLTPushBack(&plist, 3);
  79. 	SLTPushBack(&plist, 4);
  80. 	SLTPrint(plist);
  81.  
  82. 	SLTNode* ans = SLTFind(plist, 1);
  83. 	if (ans)
  84. 		ans->data = 10;
  85. 	SLTPrint(plist);
  86. }
  87.  
  88. // 在pos位置之前插入x测试
  89. void SLTTest6()
  90. {
  91. 	SLTNode* plist = NULL;
  92.  
  93. 	SLTPushBack(&plist, 1);
  94. 	SLTPushBack(&plist, 2);
  95. 	SLTPushBack(&plist, 3);
  96. 	SLTPushBack(&plist, 4);
  97. 	SLTPrint(plist);
  98.  
  99. 	SLTNode* pos = SLTFind(plist, 2);
  100. 	if (pos)
  101. 		SLTInsert(&plist, pos, 99);
  102. 	SLTPrint(plist);
  103. }
  104.  
  105. // 在pos位置之后插入x测试
  106. void SLTTest7()
  107. {
  108. 	SLTNode* plist = NULL;
  109.  
  110. 	SLTPushBack(&plist, 1);
  111. 	SLTPushBack(&plist, 2);
  112. 	SLTPushBack(&plist, 3);
  113. 	SLTPushBack(&plist, 4);
  114. 	SLTPrint(plist);
  115.  
  116. 	SLTNode* pos = SLTFind(plist, 2);
  117. 	if (pos)
  118. 		SLTInsertAfter(pos, 99);
  119. 	SLTPrint(plist);
  120. }
  121.  
  122. // 删除pos位置的值测试
  123. void SLTTest8()
  124. {
  125. 	SLTNode* plist = NULL;
  126.  
  127. 	SLTPushBack(&plist, 1);
  128. 	SLTPushBack(&plist, 2);
  129. 	SLTPushBack(&plist, 3);
  130. 	SLTPushBack(&plist, 4);
  131. 	SLTPrint(plist);
  132.  
  133. 	SLTNode* pos = SLTFind(plist, 2);
  134. 	if (pos)
  135. 		SLTErase(&plist, pos);
  136. 	SLTPrint(plist);
  137. }
  138.  
  139. // 删除pos位置之后的值测试
  140. void SLTTest9()
  141. {
  142. 	SLTNode* plist = NULL;
  143.  
  144. 	SLTPushBack(&plist, 1);
  145. 	SLTPushBack(&plist, 2);
  146. 	SLTPushBack(&plist, 3);
  147. 	SLTPushBack(&plist, 4);
  148. 	SLTPrint(plist);
  149.  
  150. 	SLTNode* pos = SLTFind(plist, 2);
  151. 	if (pos)
  152. 		SLTEraseAfter(pos);
  153. 	SLTPrint(plist);
  154. }
  155.  
  156. int main()
  157. {
  158.  
  159.  
  160.  
  161. 	return 0;
  162. }

感谢大佬们的支持！！！

互三啦！！！

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

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

  

闽ICP备14008679号