双向链表及其基本操作

标签：head temp 结点 next 链表 双向 基本操作 Line

虽然单链表能 100% 存储逻辑关系为 "一对一" 的数据，但在解决某些实际问题时，单链表的执行效率并不高。例如，若实际问题中需要频繁地查找某个结点的前驱结点，使用单链表存储数据显然没有优势，因为单链表的强项是从前往后查找目标元素，不擅长从后往前查找元素。

解决此类问题，可以建立双向链表（简称双链表）。

双向链表是什么

从名字上理解双向链表，即链表是 "双向" 的，如图 1 所示：

图 1 双向链表结构示意图

“双向”指的是各节点之间的逻辑关系是双向的，头指针通常只设置一个。

从图 1 中可以看到，双向链表中各节点包含以下 3 部分信息（如图 2 所示）：

1. 指针域：用于指向当前节点的直接前驱节点；
2. 数据域：用于存储数据元素。
3. 指针域：用于指向当前节点的直接后继节点；

图 2 双向链表的节点构成
因此，双链表的节点结构用 C 语言实现为：

1. typedef struct line{
2. struct line * prior; //指向直接前趋
3. int data;
4. struct line * next; //指向直接后继
5. }Line;

双向链表的创建

同单链表相比，双链表仅是各节点多了一个用于指向直接前驱的指针域。因此，我们可以在单链表的基础轻松实现对双链表的创建。

需要注意的是，与单链表不同，双链表创建过程中，每创建一个新节点都要与其前驱节点建立两次联系，分别是：

• 将新节点的 prior 指针指向直接前驱节点；
• 将直接前驱节点的 next 指针指向新节点；

这里给出创建双向链表的 C 语言实现代码：

1. Line* initLine(Line* head) {
2. Line* list = NULL;
3. head = (Line*)malloc(sizeof(Line));//创建链表第一个结点（首元结点）
4. head->prior = NULL;
5. head->next = NULL;
6. head->data = 1;
7. list = head;
8. for (int i = 2; i <= 5; i++) {
9. //创建并初始化一个新结点
10. Line* body = (Line*)malloc(sizeof(Line));
11. body->prior = NULL;
12. body->next = NULL;
13. body->data = i;
14. //直接前趋结点的next指针指向新结点
15. list->next = body;
16. //新结点指向直接前趋结点
17. body->prior = list;
18. list = list->next;
19. }
20. return head;
21. }

我们可以尝试着在 main 函数中输出创建的双链表，C 语言代码如下：

1. #include <stdio.h>
2. #include <stdlib.h>
3. typedef struct line {
4. struct line* prior; //指向直接前趋
5. int data;
6. struct line* next; //指向直接后继
7. }Line;
9. Line* initLine(Line* head) {
10. int i;
11. Line* list = NULL;
12. head = (Line*)malloc(sizeof(Line));//创建链表第一个结点（首元结点）
13. head->prior = NULL;
14. head->next = NULL;
15. head->data = 1;
16. list = head;
17. for (i = 2; i <= 5; i++) {
18. //创建并初始化一个新结点
19. Line* body = (Line*)malloc(sizeof(Line));
20. body->prior = NULL;
21. body->next = NULL;
22. body->data = i;
23. //直接前趋结点的next指针指向新结点
24. list->next = body;
25. //新结点指向直接前趋结点
26. body->prior = list;
27. list = list->next;
28. }
29. return head;
30. }
31. //输出链表中的数据
32. void display(Line* head) {
33. Line* temp = head;
34. while (temp) {
35. //如果该节点无后继节点，说明此节点是链表的最后一个节点
36. if (temp->next == NULL) {
37. printf("%d\n", temp->data);
38. }
39. else {
40. printf("%d <-> ", temp->data);
41. }
42. temp = temp->next;
43. }
44. }
45. //释放链表中结点占用的空间
46. void free_line(Line* head) {
47. Line* temp = head;
48. while (temp) {
49. head = head->next;
50. free(temp);
51. temp = head;
52. }
53. }
55. int main()
56. {
57. //创建一个头指针
58. Line* head = NULL;
59. //调用链表创建函数
60. head = initLine(head);
61. //输出创建好的链表
62. display(head);
63. //显示双链表的优点
64. printf("链表中第 4 个节点的直接前驱是：%d", head->next->next->next->prior->data);
65. free_line(head);
66. return 0;
67. }

程序运行结果：

1 <-> 2 <-> 3 <-> 4 <-> 5
链表中第 4 个节点的直接前驱是：3

 

基本操作

前面学习了如何创建一个双向链表，本节学习有关双向链表的一些基本操作，即如何在双向链表中添加、删除、查找或更改数据元素。

本节知识基于已熟练掌握双向链表创建过程的基础上，我们继续上节所创建的双向链表来学习本节内容，创建好的双向链表如图 1 所示：

图 1 双向链表示意图

双向链表添加节点

根据数据添加到双向链表中的位置不同，可细分为以下 3 种情况：

1) 添加至表头

将新数据元素添加到表头，只需要将该元素与表头元素建立双层逻辑关系即可。

换句话说，假设新元素节点为 temp，表头节点为 head，则需要做以下 2 步操作即可：

1. temp->next=head; head->prior=temp;
2. 将 head 移至 temp，重新指向新的表头；

例如，将新元素 7 添加至双链表的表头，则实现过程如图 2 所示：

图 2 添加元素至双向链表的表头

2) 添加至表的中间位置

同单链表添加数据类似，双向链表中间位置添加数据需要经过以下 2 个步骤，如图 3 所示：

1. 新节点先与其直接后继节点建立双层逻辑关系；
2. 新节点的直接前驱节点与之建立双层逻辑关系；

图 3 双向链表中间位置添加数据元素

3) 添加至表尾

与添加到表头是一个道理，实现过程如下（如图 4 所示）：

1. 找到双链表中最后一个节点；
2. 让新节点与最后一个节点进行双层逻辑关系；

图 4 双向链表尾部添加数据元素

因此，我们可以试着编写双向链表添加数据的 C 语言代码，参考代码如下：

1. Line* insertLine(Line* head, int data, int add) {
2. //新建数据域为data的结点
3. Line* temp = (Line*)malloc(sizeof(Line));
4. temp->data = data;
5. temp->prior = NULL;
6. temp->next = NULL;
7. //插入到链表头，要特殊考虑
8. if (add == 1) {
9. temp->next = head;
10. head->prior = temp;
11. head = temp;
12. }
13. else {
14. int i;
15. Line* body = head;
16. //找到要插入位置的前一个结点
17. for (i = 1; i < add - 1; i++) {
18. body = body->next;
19. //只要 body 不存在，表明插入位置输入错误
20. if (!body) {
21. printf("插入位置有误！\n");
22. return head;
23. }
24. }
25. //判断条件为真，说明插入位置为链表尾，实现第 2 种情况
26. if (body && (body->next == NULL)) {
27. body->next = temp;
28. temp->prior = body;
29. }
30. else {
31. //第 2 种情况的具体实现
32. body->next->prior = temp;
33. temp->next = body->next;
34. body->next = temp;
35. temp->prior = body;
36. }
37. }
38. return head;
39. }

双向链表删除节点

和添加结点的思想类似，在双向链表中删除目标结点也分为 3 种情况。

1) 删除表头结点

删除表头结点的过程如下图所示：

图 5 删除双链表表头元素

删除表头结点的实现过程是：

1. 新建一个指针指向表头结点；
2. 断开表头结点和其直接后续结点之间的关联，更改 head 头指针的指向，同时将其直接后续结点的 prior 指针指向 NULL；
3. 释放表头结点占用的内存空间。

2) 删除表中结点

删除表中结点的过程如下图所示：

图 6 删除表中结点

删除表中结点的实现过程是：

1. 找到目标结点，新建一个指针指向改结点；
2. 将目标结点从链表上摘除；
3. 释放该结点占用的内存空间。

3) 删除表尾结点

删除表尾结点的过程如下图所示：

图 7 删除表尾结点

删除表尾结点的实现过程是：

1. 找到表尾结点，新建一个指针指向该结点；
2. 断点表尾结点和其直接前驱结点的关联，并将其直接前驱结点的 next 指针指向 NULL；
3. 释放表尾结点占用的内存空间。

双向链表删除节点的 C 语言实现代码如下：

1. //删除结点的函数，data为要删除结点的数据域的值
2. Line* delLine(Line* head, int data) {
3. Line* temp = head;
4. while (temp) {
5. if (temp->data == data) {
6. //删除表头结点
7. if (temp->prior == NULL) {
8. head = head->next;
9. if (head) {
10. head->prior = NULL;
11. temp->next = NULL;
12. }
13. free(temp);
14. return head;
15. }
16. //删除表中结点
17. if (temp->prior && temp->next) {
18. temp->next->prior = temp->prior;
19. temp->prior->next = temp->next;
20. free(temp);
21. return head;
22. }
23. //删除表尾结点
24. if (temp->next == NULL) {
25. temp->prior->next = NULL;
26. temp->prior = NULL;
27. free(temp);
28. return head;
29. }
30. }
31. temp = temp->next;
32. }
33. printf("表中没有目标元素，删除失败\n");
34. return head;
35. }

双向链表查找节点

通常情况下，双向链表和单链表一样都仅有一个头指针。因此，双链表查找指定元素的实现同单链表类似，也是从表头依次遍历表中元素。

C 语言实现代码为：

1. //head为原双链表，elem表示被查找元素
2. int selectElem(line * head,int elem){
3. //新建一个指针t，初始化为头指针 head
4. line * t=head;
5. int i=1;
6. while (t) {
7. if (t->data==elem) {
8. return i;
9. }
10. i++;
11. t=t->next;
12. }
13. //程序执行至此处，表示查找失败
14. return -1;
15. }

双向链表更改节点

更改双链表中指定结点数据域的操作是在查找的基础上完成的。实现过程是：通过遍历找到存储有该数据元素的结点，直接更改其数据域即可。

实现此操作的 C 语言实现代码如下：

1. //更新函数，其中，add 表示要修改的元素，newElem 为新数据的值
2. void amendElem(Line* p, int oldElem, int newElem) {
3. Line* temp = p;
4. int find = 0;
5. //找到要修改的目标结点
6. while (temp)
7. {
8. if (temp->data == oldElem) {
9. find = 1;
10. break;
11. }
12. temp = temp->next;
13. }
14. //成功找到，则进行更改操作
15. if (find == 1) {
16. temp->data = newElem;
17. return;
18. }
19. //查找失败，输出提示信息
20. printf("链表中未找到目标元素，更改失败\n");
21. }

总结

这里给出双链表中对数据进行 "增删查改" 操作的完整实现代码：

纯文本复制

1. #include <stdio.h>
2. #include <stdlib.h>
3. typedef struct line {
4. struct line* prior; //指向直接前趋
5. int data;
6. struct line* next; //指向直接后继
7. }Line;
9. Line* initLine(Line* head) {
10. int i;
11. Line* list = NULL;
12. head = (Line*)malloc(sizeof(Line));//创建链表第一个结点（首元结点）
13. head->prior = NULL;
14. head->next = NULL;
15. head->data = 1;
16. list = head;
17. for (i = 2; i <= 5; i++) {
18. //创建并初始化一个新结点
19. Line* body = (Line*)malloc(sizeof(Line));
20. body->prior = NULL;
21. body->next = NULL;
22. body->data = i;
23. //直接前趋结点的next指针指向新结点
24. list->next = body;
25. //新结点指向直接前趋结点
26. body->prior = list;
27. list = list->next;
28. }
29. return head;
30. }
32. void display(Line* head) {
33. Line* temp = head;
34. while (temp) {
35. //如果该节点无后继节点，说明此节点是链表的最后一个节点
36. if (temp->next == NULL) {
37. printf("%d\n", temp->data);
38. }
39. else {
40. printf("%d <-> ", temp->data);
41. }
42. temp = temp->next;
43. }
44. }
46. //删除结点的函数，data为要删除结点的数据域的值
47. Line* delLine(Line* head, int data) {
48. Line* temp = head;
49. while (temp) {
50. if (temp->data == data) {
51. //删除表头结点
52. if (temp->prior == NULL) {
53. head = head->next;
54. if (head) {
55. head->prior = NULL;
56. temp->next = NULL;
57. }
58. free(temp);
59. return head;
60. }
61. //删除表中结点
62. if (temp->prior && temp->next) {
63. temp->next->prior = temp->prior;
64. temp->prior->next = temp->next;
65. free(temp);
66. return head;
67. }
68. //删除表尾结点
69. if (temp->next == NULL) {
70. temp->prior->next = NULL;
71. temp->prior = NULL;
72. free(temp);
73. return head;
74. }
75. }
76. temp = temp->next;
77. }
78. printf("表中没有目标元素，删除失败\n");
79. return head;
80. }
82. //head为原双链表，elem表示被查找元素
83. int selectElem(Line* head, int elem) {
84. //新建一个指针t，初始化为头指针 head
85. Line* t = head;
86. int i = 1;
87. while (t) {
88. if (t->data == elem) {
89. return i;
90. }
91. i++;
92. t = t->next;
93. }
94. //程序执行至此处，表示查找失败
95. return -1;
96. }
98. //更新函数，其中，add 表示要修改的元素，newElem 为新数据的值
99. void amendElem(Line* p, int oldElem, int newElem) {
100. Line* temp = p;
101. int find = 0;
102. //找到要修改的目标结点
103. while (temp)
104. {
105. if (temp->data == oldElem) {
106. find = 1;
107. break;
108. }
109. temp = temp->next;
110. }
111. //成功找到，则进行更改操作
112. if (find == 1) {
113. temp->data = newElem;
114. return;
115. }
116. //查找失败，输出提示信息
117. printf("链表中未找到目标元素，更改失败\n");
118. }
119. //释放链表中结点占用的内存空间
120. void free_line(Line* head) {
121. Line* temp = head;
122. while (temp) {
123. head = head->next;
124. free(temp);
125. temp = head;
126. }
127. }
129. int main()
130. {
131. //创建一个头指针
132. Line* head = NULL;
133. //调用链表创建函数
134. head = initLine(head);
135. printf("创建好的双向链表为:\n");
136. display(head);
138. printf("删除元素 2:\n");
139. head = delLine(head, 2);
140. display(head);
142. printf("元素 3 的位置是：%d\n", selectElem(head, 3));
144. printf("表中的元素 3 改为 6:\n");
145. amendElem(head, 3, 6);
146. display(head);
148. free_line(head);
149. return 0;
150. }

程序执行结果为：

创建好的双向链表为:
1 <-> 2 <-> 3 <-> 4 <-> 5
删除元素 2:
1 <-> 3 <-> 4 <-> 5
元素 3 的位置是：2
表中的元素 3 改为 6:
1 <-> 6 <-> 4 <-> 5

标签：head,temp,结点,next,链表,双向,基本操作,Line
From： https://www.cnblogs.com/suishou/p/16808514.html