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

数据结构——单链表的实现以及原理讲解 配图文 超详解

作者：我家自动化 | 2024-04-27 12:38:43

赞

踩

数据结构——单链表的实现以及原理讲解 配图文 超详解

目录

1.单链表的概念及结构

1.1 概念

2.单链表的实现

2.1 List.h

2.2 List.cpp

2.2.1 init()初始化函数

2.2.2 Newnode()创建新结点

2.2.3 Pushfront()头插函数

2.2.4 Pushback()尾插函数

2.2.5 Popfront()头删函数

2.2.6 Popback()尾删函数

2.2.7  Find()查找函数

2.2.8 Insertfront()在指定位置之前插入元素

2.2.9 Insertback()指定位置之后插入元素

2.2.10 Erasepos() 删除指定位置的元素

2.2.11 Destory()单链表的销毁

 2.2.12 print()单链表的打印

2.3 test.cpp

3.运行结果:

1.单链表的概念及结构

1.1 概念

        链表是一种物理存储结构上非连续，非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的(指针就相当于链条，把每一个数据串了起来)。

        与顺序表不同的是，链表里的每个节点都是独立申请来的空间，一般称为结点，结点的组成有两部分，当前结点要保存的数据和下一结点的地址。

 data就是数据域

next就是指针域

                   

2.单链表的实现

采用头文件与执行文件分离的方法:

2.1 List.h

源码:

  1. #pragma once
  2. #define _CRT_SECURE_NO_WARNINGS 1
  3.  
  4. #include<iostream>
  5. #include<stdlib.h>
  6.  
  7. using namespace std;
  8.  
  9. typedef int Datatype;
  10.  
  11. struct List
  12. {
  13. 	Datatype data;
  14. 	struct List* next;
  15. };
  16.  
  17. typedef struct List List;
  18.  
  19. void init(List** ls);
  20. List* Newnode(Datatype x);//生成节点
  21. void print(List* ls);//打印
  22. void Pushfront(List** sl, Datatype x);
  23. void Pushback(List** sl, Datatype x);
  24. void Popfront(List** sl);
  25. void Popback(List** sl);
  26. List* Find(List* sl, Datatype x);
  27. void Insertfront(List** sl, List* pos, Datatype x);//指定位置之前
  28. void Insertback(List** sl, List* pos, Datatype x);//指定位置之后
  29. void Erasepos(List** sl, List* pos);//删除指定位置
  30. void Eraseposback(List** sl, List* pos);//删除pos之后的
  31. void Destory(List** sl);
  32. void menu();
  33.

(1).在自定义头文件中存放单链表所需的头文件，定义结构体，以及函数的声明。

(2).在结构体中，Datatype data 为数据域， struct List* next 为指针域

2.2 List.cpp

源码

  1.  
  2. #include"List.h"
  3.  
  4. void init(List** sl)
  5. {
  6. 	(*sl)->next = NULL;
  7. 	(*sl)->data = 0;
  8. }
  9.  
  10. void menu()
  11. {
  12. 	printf("********************************\n");
  13. 	printf("***1.Pushfront     2.Pushback***\n");
  14. 	printf("***3.Popfront       4.Popback***\n");
  15. 	printf("***5.Insertfront 6.Insertback***\n");
  16. 	printf("***7.Erasepos  8.Eraseposback***\n");
  17. 	printf("***9.Destory         10.print***\n");
  18. 	printf("*********** 0.exit *************\n");
  19. 	printf("********************************\n");
  20. }
  21.  
  22. List* Newnode(Datatype x)//生成节点
  23. {
  24. 	List* node = (List*)malloc(sizeof(List));
  25. 	if (node == NULL)
  26. 	{
  27. 		printf("malloc is failed\n");
  28. 		return NULL;
  29. 	}
  30. 	node->data = x;
  31. 	node->next = NULL;
  32. 	return node;
  33. }
  34. void print(List* ls)//打印
  35. {
  36. 	if (ls == NULL)
  37. 	{
  38. 		printf("ls is NULL\n");
  39. 		return;
  40. 	}
  41.  
  42. 	List* cur = ls;
  43. 	while (cur)
  44. 	{
  45. 		cout << cur->data << ' ';
  46. 		cur = cur->next;
  47. 	}
  48. 	cout << endl;
  49. }
  50.  
  51. void Pushfront(List** sl, Datatype x)
  52. {
  53. 	if (sl == NULL)
  54. 	{
  55. 		printf("sl is NULL\n");
  56. 		return;
  57. 	}
  58. 	List* node = Newnode(x);
  59.  
  60. 	node->next = (*sl);
  61.  
  62. 	(*sl) = node;
  63.  
  64. }
  65. void Pushback(List** sl, Datatype x)
  66. {
  67. 	List* node = Newnode(x);
  68. 	if (sl == NULL)
  69. 	{
  70. 		printf("sl is NULL\n");
  71. 		return;
  72. 	}
  73. 	if ((*sl) == NULL)
  74. 	{
  75. 		(*sl) = node;
  76. 		return;
  77. 	}
  78.  
  79. 	List* cur = (*sl);
  80.  
  81. 	while (cur->next)
  82. 	{
  83. 		cur = cur->next;
  84. 	}
  85.  
  86. 	cur->next = node;
  87.  
  88. }
  89. void Popfront(List** sl)
  90. {
  91. 	if (sl == NULL || (*sl) == NULL)
  92. 	{
  93. 		printf("ls is empty!\n");
  94. 		return;
  95. 	}
  96. 	List* cur = (*sl)->next;
  97. 	//free(*sl);
  98. 	(*sl) = cur;
  99. }
  100. void Popback(List** sl)
  101. {
  102.  
  103. 	if (sl == NULL || (*sl) == NULL)
  104. 	{
  105. 		printf("ls is empty!\n");
  106. 		return;
  107. 	}
  108.  
  109. 	List* pre = NULL; List* cur = (*sl);
  110. 	
  111. 	if ((*sl)->next == NULL)
  112. 	{
  113. 		free(*sl);
  114. 		*sl = NULL;
  115. 	}
  116. 	else
  117. 	{
  118. 		while (cur->next)
  119. 		{
  120. 			pre = cur;
  121. 			cur = cur->next;
  122. 		}
  123. 		free(cur);
  124. 		cur = NULL;
  125. 		pre->next = NULL;
  126. 	}
  127. 	
  128. }
  129.  
  130. List* Find(List* sl, Datatype x)
  131. {
  132. 	List* cur = sl;
  133.  
  134. 	while (cur && cur->data != x)
  135. 	{
  136. 		cur = cur->next;
  137. 	}
  138.  
  139. 	if (cur == NULL)
  140. 	{
  141. 		printf("not have x\n");
  142. 		return NULL;
  143. 	}
  144.  
  145. 	return cur;
  146.  
  147. }
  148.  
  149. void Insertfront(List** sl, List* pos, Datatype x)//指定位置之前
  150. {
  151. 	if (sl == NULL)
  152. 	{
  153. 		printf("sl is NULL\n");
  154. 		return;
  155. 	}
  156. 	List* node = Newnode(x);
  157. 	List* pre = NULL;
  158. 	List* cur = (*sl);
  159. 	if (pos == *sl)
  160. 	{
  161. 		Pushfront(sl, x);
  162. 	}
  163.  
  164. 	else
  165. 	{
  166. 		while (cur != pos)
  167. 		{
  168. 			pre = cur;
  169. 			cur = cur->next;
  170. 		}
  171. 		pre->next = node;
  172. 		node->next = pos;
  173. 	}
  174. 	
  175.  
  176. }
  177. void Insertback(List** sl, List* pos, Datatype x)//指定位置之后
  178. {
  179. 	if (sl == NULL)
  180. 	{
  181. 		printf("sl is NULL\n");
  182. 		return;
  183. 	}
  184. 	List* node = Newnode(x);
  185. 	List* cur = (*sl);
  186. 	while (cur != pos)
  187. 	{
  188. 		cur = cur->next;
  189. 	}
  190.  
  191. 	node->next = pos->next;
  192. 	pos->next = node;
  193. }
  194.  
  195.  
  196. void Erasepos(List** sl, List* pos)//删除指定位置
  197. {
  198. 	if (sl == NULL)
  199. 	{
  200. 		printf("sl is NULL\n");
  201. 		return;
  202. 	}
  203. 	if ((*sl) == NULL)
  204. 	{
  205. 		printf("sl is empty\n");
  206. 		return;
  207. 	}
  208. 	List* cur = (*sl);
  209. 	if (pos == *sl)
  210. 	{
  211. 		Popfront(sl);
  212. 	}
  213. 	else
  214. 	{
  215. 		while (cur->next != pos)
  216. 		{
  217. 			cur = cur->next;
  218. 		}
  219. 		cur->next = pos->next;
  220. 		free(pos);
  221. 	}
  222. 	
  223. }
  224. void Eraseposback(List** sl, List* pos)//删除pos之后的
  225. {
  226. 	if (sl == NULL)
  227. 	{
  228. 		printf("sl is NULL\n");
  229. 		return;
  230. 	}
  231. 	if ((*sl) == NULL)
  232. 	{
  233. 		printf("sl is empty\n");
  234. 		return;
  235. 	}
  236. 	if (pos->next)
  237. 	{
  238. 		List* pre = pos->next;
  239. 		pos->next = pos->next->next;
  240. 		free(pre);
  241. 		pre = NULL;
  242. 	}
  243. 	
  244.  
  245. }
  246.  
  247. void Destory(List** sl)
  248. {
  249. 	if (sl == NULL)
  250. 	{
  251. 		printf("sl is destory\n");
  252. 		return;
  253. 	}
  254. 	List* cur = *sl;
  255. 	List* next = NULL;
  256. 	while (cur)
  257. 	{
  258. 		next = cur->next;
  259. 		free(cur);
  260. 		cur = next;
  261. 	}
  262.  
  263. 	cur = NULL;
  264. 	next = NULL;
  265. 	*sl = NULL;
  266.  
  267. }

 

2.2.1 init()初始化函数

  1. void init(List** sl)
  2. {
  3. 	(*sl)->next = NULL;
  4. 	(*sl)->data = 0;
  5. }

(1).将最初的头结点初始化，把最初的头结点中next指针置为NULL,并把值赋值为0。

 

2.2.2 Newnode()创建新结点

  1. List* Newnode(Datatype x)//生成节点
  2. {
  3. 	List* node = (List*)malloc(sizeof(List));
  4. 	if (node == NULL)
  5. 	{
  6. 		printf("malloc is failed\n");
  7. 		return NULL;
  8. 	}
  9. 	node->data = x;
  10. 	node->next = NULL;
  11. 	return node;
  12. }

(1).由于要创建新结点，所以要返回创建的新结点，函数返回值为List* 。

(2).函数只需要传递结点中要存放的值即可。

(3).使用malloc()函数来申请空间，申请完成后要判断是否申请成功。

(4).将新结点的数据域赋值为x，指针域赋为NULL。

(5).最后返回新结点。

2.2.3 Pushfront()头插函数

  1. void Pushfront(List** head, Datatype x)
  2. {
  3. 	if (head == NULL)
  4. 	{
  5. 		printf("head is NULL\n");
  6. 		return;
  7. 	}
  8. 	List* newnode= Newnode(x);
  9.  
  10. 	newnode->next = (*head);
  11.  
  12. 	(*head) = newnode;
  13.  
  14. }

(1).首先判断头节点是否为空指针。

(2).头插，就是要创建一个新结点，然后拼接到链表前方，所以，定义一个结构体指针变量，用来存储创建的新结点，然后先把新结点的下一指针指向头节点，再让头节点指向新结点，这样就使得头节点再次成为最前面的结点了。

(3).图文解释:

newnode->next = (*head);

 

(*head) = newnode;

 

 

 

2.2.4 Pushback()尾插函数

  1. void Pushback(List** head, Datatype x)
  2. {
  3. 	List* newnode= Newnode(x);
  4. 	if (head == NULL)
  5. 	{
  6. 		printf("head is NULL\n");
  7. 		return;
  8. 	}
  9. 	if ((*head) == NULL)
  10. 	{
  11. 		(*head) = newnode;
  12. 		return;
  13. 	}
  14.  
  15. 	List* cur = (*head);
  16.  
  17. 	while (cur->next)
  18. 	{
  19. 		cur = cur->next;
  20. 	}
  21.  
  22. 	cur->next = newnode;
  23.  
  24. }

(1).首先判断头节点是否为空指针。

(2).在判断链表是否为空，若边表为空，则直接将头指针赋值为新结点。

(3).若链表不为空，则新定义一个结构体指针cur，使cur指向头节点，从链表初始位置遍历到链表最后一个位置，即cur->next==NULL时。cur到达最后一个结点后，使最后一个结点的next指向新创建的结点。

当链表尾空时，只有一个头指针。

(*head) = newnode;

 

  1. while (cur->next)
  2. {
  3. 	cur = cur->next;
  4. }
  5.  
  6. cur->next = newnode;

此时，cur->next==NULL成立，退出循环。

2.2.5 Popfront()头删函数

  1. void Popfront(List** head)
  2. {
  3. 	if (head == NULL || (*head) == NULL)
  4. 	{
  5. 		printf("ls is empty!\n");
  6. 		return;
  7. 	}
  8. 	List* cur = (*head)->next;
  9. 	free(*head);
  10. 	(*head) = cur;
  11. }

(1).新定义一个结构体指针cur，使cur指向头结点的下一个结点。

(2).再把现在的头节点释放。

(3).再使得头节点指向cur。

图文：

第一步：

List* cur = (*head)->next;

 第二步：

free(*head);

 

第三步：

(*head) = cur;

2.2.6 Popback()尾删函数

  1. void Popback(List** head)
  2. {
  3.  
  4. 	if (head== NULL || (*head) == NULL)
  5. 	{
  6. 		printf("headis empty!\n");
  7. 		return;
  8. 	}
  9.  
  10. 	List* pre = NULL; List* cur = (*head);
  11. 	
  12. 	if ((*head)->next == NULL)
  13. 	{
  14. 		free(*head);
  15. 		*head= NULL;
  16. 	}
  17. 	else
  18. 	{
  19. 		while (cur->next)
  20. 		{
  21. 			pre = cur;
  22. 			cur = cur->next;
  23. 		}
  24. 		free(cur);
  25. 		cur = NULL;
  26. 		pre->next = NULL;
  27. 	}
  28. 	
  29. }

(1).如果链表中只有一个结点，则直接释放头结点即可。

(2).如果不只有一个结点，则需要定义两个结构体指针，pre和cur，使pre始终在cur之前的一位，则当cur到达最后一个结点时，pre在倒数第二个结点，此时，释放cur结点，再令pre的next指针指向NULL。

图文：

2.2.7  Find()查找函数

  1. List* Find(List* head, Datatype x)
  2. {
  3. 	List* cur = head;
  4.  
  5. 	while (cur && cur->data != x)
  6. 	{
  7. 		cur = cur->next;
  8. 	}
  9.  
  10. 	if (cur == NULL)
  11. 	{
  12. 		printf("not have x\n");
  13. 		return NULL;
  14. 	}
  15.  
  16. 	return cur;
  17.  
  18. }

(1).定义结构体指针cur，循环查找，条件为cur不为空指针，并且cur所指的结点的值不等于要查找的值。

(2).当cur为空时并且在这之前都没有匹配到x，则此时cur指到了链表尾部，说明链表中不存在要查找的值。反之则找到了，返回该结点的地址。

2.2.8 Insertfront()在指定位置之前插入元素

  1. void Insertfront(List** head, List* pos, Datatype x)//指定位置之前
  2. {
  3. 	if (head == NULL)
  4. 	{
  5. 		printf("sl is NULL\n");
  6. 		return;
  7. 	}
  8. 	List* node = Newnode(x);
  9. 	List* pre = NULL;
  10. 	List* cur = (*head);
  11. 	if (pos == *head)
  12. 	{
  13. 		Pushfront(head, x);
  14. 	}
  15.  
  16. 	else
  17. 	{
  18. 		while (cur != pos)
  19. 		{
  20. 			pre = cur;
  21. 			cur = cur->next;
  22. 		}
  23. 		pre->next = node;
  24. 		node->next = pos;
  25. 	}
  26. }

(1).首先创建新结点，再创建pre和cur，pre始终在cur之前的一位。

(2).如果要插入的位置(pos)刚好在头结点处，则直接调用头插即可。

(3).如果(pos)不在头结点，则使cur循环至pos的位置，此时pre位于pos前一位，使pre的next指向新结点，再使新结点的next指向pos。

图文：

2.2.9 Insertback()指定位置之后插入元素

  1. void Insertback(List** head, List* pos, Datatype x)//指定位置之后
  2. {
  3. 	if (head== NULL)
  4. 	{
  5. 		printf("head is NULL\n");
  6. 		return;
  7. 	}
  8. 	List* node = Newnode(x);
  9.  
  10. 	node->next = pos->next;
  11. 	pos->next = node;
  12. }

(1).创建新结点。

(2).令新结点的next指向pos的next，再让pos的next指向新结点。

图文：

 

2.2.10 Erasepos() 删除指定位置的元素

  1. void Erasepos(List** sl, List* pos)//删除指定位置
  2. {
  3. 	if (sl == NULL)
  4. 	{
  5. 		printf("sl is NULL\n");
  6. 		return;
  7. 	}
  8. 	if ((*sl) == NULL)
  9. 	{
  10. 		printf("sl is empty\n");
  11. 		return;
  12. 	}
  13. 	List* cur = (*sl);
  14. 	if (pos == *sl)
  15. 	{
  16. 		Popfront(sl);
  17. 	}
  18. 	else
  19. 	{
  20. 		while (cur->next != pos)
  21. 		{
  22. 			cur = cur->next;
  23. 		}
  24. 		cur->next = pos->next;
  25. 		free(pos);
  26. 	}
  27. 	
  28. }

(1).如果pos与头结点相同，则直接调用头删。

(2).定义一个cur指针，循环至pos结点之前的一个结点，再让cur的next指向pos

的next，最后释放pos。

图文:

 

2.2.11 Destory()单链表的销毁

  1. void Destory(List** sl)
  2. {
  3. 	if (sl == NULL)
  4. 	{
  5. 		printf("sl is destory\n");
  6. 		return;
  7. 	}
  8. 	List* cur = *sl;
  9. 	List* next = NULL;
  10. 	while (cur)
  11. 	{
  12. 		next = cur->next;
  13. 		free(cur);
  14. 		cur = next;
  15. 	}
  16.  
  17. 	cur = NULL;
  18. 	next = NULL;
  19. 	*sl = NULL;
  20.  
  21. }

(1).要使得单链表中全部的结点销毁，就要遍历单链表。

(2).先使得next 保存cur的下一个结点地址，然后释放cur，再使得cur指向next，循环往复。

图文：

 

 2.2.12 print()单链表的打印

  1. void print(List* ls)//打印
  2. {
  3. 	if (ls == NULL)
  4. 	{
  5. 		printf("ls is NULL\n");
  6. 		return;
  7. 	}
  8.  
  9. 	List* cur = ls;
  10. 	while (cur)
  11. 	{
  12. 		cout << cur->data << ' ';
  13. 		cur = cur->next;
  14. 	}
  15. 	cout << endl;
  16. }

(1).只需遍历单链表，依次打印每个结点存储的值即可。

2.3 test.cpp

源码：

  1. #include"List.h"
  2.  
  3.  
  4.  
  5.  
  6. int main()
  7. {
  8.  
  9. 	List* node = NULL;
  10. 	//init(&node);
  11. 	Datatype x;
  12. 	Datatype y;
  13. 	List* POS = NULL;
  14. 	int op;
  15. 	int n;
  16. 	do
  17. 	{
  18. 		menu();
  19. 		printf("input option \n");
  20. 		cin >> op;
  21.  
  22. 		switch (op)
  23. 		{
  24. 		case 1:
  25. 			printf("input element number\n");
  26. 			cin >> n;
  27. 			while (n--)
  28. 			{
  29. 				cin >> x;
  30. 				Pushfront(&node, x);
  31. 			}
  32. 			break;
  33. 		case 2:
  34. 			printf("input element number\n");
  35. 			cin >> n;
  36. 			while (n--)
  37. 			{
  38. 				cin >> x;
  39. 				Pushback(&node, x);
  40. 			}
  41. 			break;
  42. 		case 3:
  43. 			Popfront(&node);
  44. 			break;
  45. 		case 4:
  46. 			Popback(&node);
  47. 			break;
  48. 		case 5:
  49. 			printf("input insert position \n");
  50. 			cin >> y;
  51. 			POS = Find(node,y);
  52. 			if (POS == NULL)
  53. 			{
  54. 				printf("y is not in List\n");
  55. 			}
  56. 			else
  57. 			{
  58. 				printf("input insert element\n");
  59. 				cin >> x;
  60. 				Insertfront(&node, POS, x);
  61. 			}
  62. 			break;
  63. 		case 6:
  64. 			printf("input insert position \n");
  65. 			cin >> y;
  66. 			POS = Find(node, y);
  67. 			if (POS == NULL)
  68. 			{
  69. 				printf("y is not in List\n");
  70. 			}
  71. 			else
  72. 			{
  73. 				printf("input insert element\n");
  74. 				cin >> x;
  75. 				Insertback(&node, POS, x);
  76. 			}
  77. 			break;
  78. 		case 7:
  79. 			printf("input insert position \n");
  80. 			cin >> y;
  81. 			POS = Find(node, y);
  82. 			if (POS == NULL)
  83. 			{
  84. 				printf("y is not in List\n");
  85. 			}
  86. 			else
  87. 			{
  88. 				Erasepos(&node,POS);
  89. 			}
  90. 			break;
  91. 		case 8:
  92. 			printf("input insert position \n");
  93. 			cin >> y;
  94. 			POS = Find(node, y);
  95. 			if (POS == NULL)
  96. 			{
  97. 				printf("y is not in List\n");
  98. 			}
  99. 			else
  100. 			{
  101. 				Eraseposback(&node, POS);
  102. 			}
  103. 			break;
  104. 		case 9:
  105. 			Destory(&node);
  106. 			break;
  107. 		case 10:
  108. 			print(node);
  109. 			break;
  110. 		case 0:
  111. 			break;
  112. 		default:
  113. 			printf("please reinput \n");
  114. 			break;
  115. 		}
  116.  
  117. 	} while (op);
  118.  
  119.  
  120. 	return 0;
  121. }
  122.

3.运行结果:

以上就是单链表的知识啦，如果你喜欢博主的文章，请给博主点点赞吧

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

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