zoukankan      html  css  js  c++  java
  • 双向链表的基本操作

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

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


    双向链表示意图
    图 1 双向链表示意图

    双向链表添加节点

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

    添加至表头

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

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

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


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


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

    添加至表的中间位置

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

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

    双向链表中间位置添加数据元素
    图 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. }else{
    13. line * body=head;
    14. //找到要插入位置的前一个结点
    15. for (int i=1; i<add-1; i++) {
    16. body=body->next;
    17. }
    18. //判断条件为真,说明插入位置为链表尾
    19. if (body->next==NULL) {
    20. body->next=temp;
    21. temp->prior=body;
    22. }else{
    23. body->next->prior=temp;
    24. temp->next=body->next;
    25. body->next=temp;
    26. temp->prior=body;
    27. }
    28. }
    29. return head;
    30. }

    双向链表删除节点

    双链表删除结点时,只需遍历链表找到要删除的结点,然后将该节点从表中摘除即可。

    例如,从图 1 基础上删除元素 2 的操作过程如图 5 所示:



    双链表删除元素操作示意图
    图 5 双链表删除元素操作示意图


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

    1. //删除结点的函数,data为要删除结点的数据域的值
    2. line * delLine(line * head,int data){
    3. line * temp=head;
    4. //遍历链表
    5. while (temp) {
    6. //判断当前结点中数据域和data是否相等,若相等,摘除该结点
    7. if (temp->data==data) {
    8. temp->prior->next=temp->next;
    9. temp->next->prior=temp->prior;
    10. free(temp);
    11. return head;
    12. }
    13. temp=temp->next;
    14. }
    15. printf("链表中无该数据元素");
    16. return head;
    17. }

    双向链表查找节点

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

    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. line *amendElem(line * p,int add,int newElem){
    3. line * temp=p;
    4. //遍历到被删除结点
    5. for (int i=1; i<add; i++) {
    6. temp=temp->next;
    7. }
    8. temp->data=newElem;
    9. return p;
    10. }

    总结

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

    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;
    8. //双链表的创建
    9. line* initLine(line * head);
    10. //双链表插入元素,add表示插入位置
    11. line * insertLine(line * head,int data,int add);
    12. //双链表删除指定元素
    13. line * delLine(line * head,int data);
    14. //双链表中查找指定元素
    15. int selectElem(line * head,int elem);
    16. //双链表中更改指定位置节点中存储的数据,add表示更改位置
    17. line *amendElem(line * p,int add,int newElem);
    18. //输出双链表的实现函数
    19. void display(line * head);
    20. int main() {
    21. line * head=NULL;
    22. //创建双链表
    23. head=initLine(head);
    24. display(head);
    25. //在表中第 3 的位置插入元素 7
    26. head=insertLine(head, 7, 3);
    27. display(head);
    28. //表中删除元素 2
    29. head=delLine(head, 2);
    30. display(head);
    31. printf("元素 3 的位置是:%d ",selectElem(head,3));
    32. //表中第 3 个节点中的数据改为存储 6
    33. head = amendElem(head,3,6);
    34. display(head);
    35. return 0;
    36. }
    37. line* initLine(line * head){
    38. head=(line*)malloc(sizeof(line));
    39. head->prior=NULL;
    40. head->next=NULL;
    41. head->data=1;
    42. line * list=head;
    43. for (int i=2; i<=5; i++) {
    44. line * body=(line*)malloc(sizeof(line));
    45. body->prior=NULL;
    46. body->next=NULL;
    47. body->data=i;
    48. list->next=body;
    49. body->prior=list;
    50. list=list->next;
    51. }
    52. return head;
    53. }
    54. line * insertLine(line * head,int data,int add){
    55. //新建数据域为data的结点
    56. line * temp=(line*)malloc(sizeof(line));
    57. temp->data=data;
    58. temp->prior=NULL;
    59. temp->next=NULL;
    60. //插入到链表头,要特殊考虑
    61. if (add==1) {
    62. temp->next=head;
    63. head->prior=temp;
    64. head=temp;
    65. }else{
    66. line * body=head;
    67. //找到要插入位置的前一个结点
    68. for (int i=1; i<add-1; i++) {
    69. body=body->next;
    70. }
    71. //判断条件为真,说明插入位置为链表尾
    72. if (body->next==NULL) {
    73. body->next=temp;
    74. temp->prior=body;
    75. }else{
    76. body->next->prior=temp;
    77. temp->next=body->next;
    78. body->next=temp;
    79. temp->prior=body;
    80. }
    81. }
    82. return head;
    83. }
    84. line * delLine(line * head,int data){
    85. line * temp=head;
    86. //遍历链表
    87. while (temp) {
    88. //判断当前结点中数据域和data是否相等,若相等,摘除该结点
    89. if (temp->data==data) {
    90. temp->prior->next=temp->next;
    91. temp->next->prior=temp->prior;
    92. free(temp);
    93. return head;
    94. }
    95. temp=temp->next;
    96. }
    97. printf("链表中无该数据元素");
    98. return head;
    99. }
    100. //head为原双链表,elem表示被查找元素
    101. int selectElem(line * head,int elem){
    102. //新建一个指针t,初始化为头指针 head
    103. line * t=head;
    104. int i=1;
    105. while (t) {
    106. if (t->data==elem) {
    107. return i;
    108. }
    109. i++;
    110. t=t->next;
    111. }
    112. //程序执行至此处,表示查找失败
    113. return -1;
    114. }
    115. //更新函数,其中,add 表示更改结点在双链表中的位置,newElem 为新数据的值
    116. line *amendElem(line * p,int add,int newElem){
    117. line * temp=p;
    118. //遍历到被删除结点
    119. for (int i=1; i<add; i++) {
    120. temp=temp->next;
    121. }
    122. temp->data=newElem;
    123. return p;
    124. }
    125. //输出链表的功能函数
    126. void display(line * head){
    127. line * temp=head;
    128. while (temp) {
    129. if (temp->next==NULL) {
    130. printf("%d ",temp->data);
    131. }else{
    132. printf("%d->",temp->data);
    133. }
    134. temp=temp->next;
    135. }
    136. }

    程序执行结果为:

    1->2->3->4->5
    1->2->7->3->4->5
    1->7->3->4->5
    元素 3 的位置是:3
    1->7->6->4->5

  • 相关阅读:
    70 sudo-用来以其他身份来执行命令
    69 su -用户和工作组管理
    68 id -显示用户的id
    71 fdisk-Linux 的磁盘分区表操作工具。
    《刘润·5分钟商学院》学习总结01
    批量创建用户和密码
    20 seq 某个数到另外一个数之间的所有整数
    grub.conf文件参数详解
    dig 常用的域名查询工具
    请问-bash-4.1$ 出现故障的原理及解决办法?
  • 原文地址:https://www.cnblogs.com/pudonglin/p/13217534.html
Copyright © 2011-2022 走看看