双向链表及其基本操作

虽然单链表能 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

posted @ 2022-10-20 08:52  随手一只风  阅读(560)  评论(0)  编辑  收藏  举报