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

【数据结构】线性表（四）双向链表的各种操作（插入、删除、查找、修改、遍历打印）_线性表的插入和删除

作者：小丑西瓜9 | 2024-04-20 09:03:25

赞

踩

线性表的插入和删除

目录

线性表的定义及其基本操作（顺序表插入、删除、查找、修改）

四、线性表的链接存储结构

1. 单链表

2. 循环链表

3. 双向链表

a. 双向链表节点结构

b. 创建一个新的节点

c. 在链表末尾插入节点

d. 在指定位置插入节点

e. 删除指定位置的节点

f. 遍历并打印链表

g. 主函数

h. 代码整合

五、复杂性分析

1. 空间效率比较

2. 时间效率比较


 

线性表的定义及其基本操作（顺序表插入、删除、查找、修改）

        一个线性表是由零个或多个具有相同类型的结点组成的有序集合。

         按照线性表结点间的逻辑顺序依次将它们存储于一组地址连续的存储单元中的存储方式被称为线性表的顺序存储方式。按顺序存储方式存储的线性表具有顺序存储结构，一般称之为顺序表。换言之，在程序中采用定长的一维数组，按照顺序存储方式存储的线性表，被称为顺序表。

【数据结构】线性表（一）线性表的定义及其基本操作（顺序表插入、删除、查找、修改）-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/m0_63834988/article/details/132089038?spm=1001.2014.3001.5501

四、线性表的链接存储结构

1. 单链表

        顺序表的优点是存取速度快。但是，无论是插入一个结点，还是删除一个结点，都需要调整一批结点的地址。要克服该缺点，就必须给出一种不同于顺序存储的存储方式。用链接存储方式存储的线性表被称为链表，可以克服上述缺点。

        链表中的结点用存储单元（若干个连续字节）来存放，存储单元之间既可以是（存储空间上）连续的，也可以是不连续的，甚至可以零散地分布在存储空间中的任何位置。换言之，链表中结点的逻辑次序和物理次序之间并无必然联系。最重要的是，链表可以在不移动结点位置的前提下根据需要随时添加删除结点，动态调整。

【数据结构】线性表（二）单链表及其基本操作（创建、插入、删除、修改、遍历打印）-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/m0_63834988/article/details/133914875?spm=1001.2014.3001.5501

2. 循环链表

           从单链表的一个结点出发，只能访问到链接在它后面的结点，而无法访问位于它前面的结点，这对一些实际应用很不方便。解决的办法是把链接结构“循环化”，即把表尾结点的next域存放指向哨位结点的指针，而不是存放空指针NULL，这样的单链表被称为循环链表。循环链表使用户可以从链表的任何位置开始，访问链表中的任意结点。

​

【数据结构】线性表（三）循环链表的各种操作（创建、插入、查找、删除、修改、遍历打印、释放内存空间）-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/m0_63834988/article/details/133914085?spm=1001.2014.3001.5501

3. 双向链表

        在循环链表中，从一个结点出发，必须遍历整个链表，方可找到其前驱结点，时间复杂度为O(n) . 双向链表将很好地解决该问题。所谓双向链表，系指链表中任一结点P都是由data域、左指针域left（pre）和右指针域right(next)构成的，左指针域和右指针域分别存放P的左右两边相邻结点的地址信息。

​

        双向链表的优点是可以在常量时间内删除或插入一个节点，因为只需要修改节点的前后指针，而不需要像单向链表那样遍历到指定位置。而在单向链表中，删除或插入一个节点需要先找到前一个节点，然后修改指针。然而，双向链表相对于单向链表需要更多的内存空间来存储额外的指针。另外，由于多了一个指针，插入和删除节点时需要更多的操作。

a. 双向链表节点结构

  1. typedef struct Node {
  2.     int data;
  3.     struct Node* prev;
  4.     struct Node* next;
  5. } Node;

        包含一个整数data以及两个指针prev和next，分别指向前一个节点和后一个节点。

b. 创建一个新的节点

  1. Node* createNode(int data) {
  2.     Node* newNode = (Node*)malloc(sizeof(Node));
  3.     newNode->data = data;
  4.     newNode->prev = NULL;
  5.     newNode->next = NULL;
  6.     return newNode;
  7. }

        创建一个新的节点，它接受一个整数作为参数，并分配内存来存储节点。然后，节点的data被设置为传入的整数，prev和next指针被初始化为NULL，最后返回新创建的节点指针。

c. 在链表末尾插入节点

  1. void append(Node** head, int data) {
  2.     Node* newNode = createNode(data);
  3.     if (*head == NULL) {
  4.         *head = newNode;
  5.     } else {
  6.         Node* current = *head;
  7.         while (current->next != NULL) {
  8.             current = current->next;
  9.         }
  10.         current->next = newNode;
  11.         newNode->prev = current;
  12.     }
  13. }
  • 创建一个新的节点，并将传入的整数作为节点的数据。
  • 检查链表是否为空
    • 如果为空，将链表头指针指向新节点；
    • 否则，遍历链表找到最后一个节点，将最后一个节点的next指针指向新节点，新节点的prev指针指向最后一个节点。

d. 在指定位置插入节点

  1. void insert(Node** head, int data, int position) {
  2.     Node* newNode = createNode(data);
  3.     if (position == 0) {
  4.         newNode->next = *head;
  5.         if (*head != NULL) {
  6.             (*head)->prev = newNode;
  7.         }
  8.         *head = newNode;
  9.     } else {
  10.         Node* current = *head;
  11.         int i;
  12.         for (i = 0; i < position - 1 && current != NULL; i++) {
  13.             current = current->next;
  14.         }
  15.         if (current == NULL) {
  16.             printf("Invalid position\n");
  17.             return;
  18.         }
  19.         newNode->next = current->next;
  20.         newNode->prev = current;
  21.         if (current->next != NULL) {
  22.             current->next->prev = newNode;
  23.         }
  24.         current->next = newNode;
  25.     }
  26. }
  • 创建一个新的节点，并将传入的整数作为节点的数据。
  • 如果插入位置为0，表示在链表头插入新节点
    • 将新节点的next指针指向链表的头节点
    • 如果链表不为空，将链表的头节点的prev指针指向新节点，最后将链表的头指针指向新节点。
  • 如果插入位置不为0
    • 首先遍历链表找到插入位置的前一个节点
    • 如果找到了位置或者遍历到链表末尾都没有找到指定位置，则输出"Invalid position"并返回。
    • 否则，将新节点的next指针指向当前节点的next指针所指向的节点，新节点的prev指针指向当前节点
    • 如果当前节点的next指针不为空，将当前节点的next指针所指向的节点的prev指针指向新节点，最后将当前节点的next指针指向新节点。

e. 删除指定位置的节点

  1. void delete(Node** head, int position) {
  2.     if (*head == NULL) {
  3.         printf("List is empty\n");
  4.         return;
  5.     }
  6.     Node* temp = *head;
  7.     if (position == 0) {
  8.         *head = (*head)->next;
  9.         if (*head != NULL) {
  10.             (*head)->prev = NULL;
  11.         }
  12.         free(temp);
  13.     } else {
  14.         int i;
  15.         for (i = 0; i < position && temp != NULL; i++) {
  16.             temp = temp->next;
  17.         }
  18.         if (temp == NULL) {
  19.             printf("Invalid position\n");
  20.             return;
  21.         }
  22.         temp->prev->next = temp->next;
  23.         if (temp->next != NULL) {
  24.             temp->next->prev = temp->prev;
  25.         }
  26.         free(temp);
  27.     }
  28. }
  • 如果链表为空，输出"List is empty"并返回。
  • 如果要删除的节点是链表的头节点
    • 将链表的头指针指向头节点的下一个节点，如果链表不为空，将新的头节点的prev指针指向NULL，然后释放被删除的节点的内存。
  • 如果要删除的节点不是头节点
    • 首先遍历链表找到要删除的节点
    • 如果找到了指定位置的节点或者遍历到链表末尾都没有找到，则输出"Invalid position"并返回。
    • 否则，将要删除节点的前一个节点的next指针指向要删除节点的下一个节点，如果要删除节点的下一个节点不为空，将要删除节点的下一个节点的prev指针指向要删除节点的前一个节点。
    • 最后释放要删除节点的内存。

f. 遍历并打印链表

  1. void printList(Node* head) {
  2.     Node* current = head;
  3.     while (current != NULL) {
  4.         printf("%d ", current->data);
  5.         current = current->next;
  6.     }
  7.     printf("\n");
  8. }

        从链表的头节点开始，通过不断访问next指针，打印每个节点的数据，并移动到下一个节点，直到遍历完整个链表。

g. 主函数

  1. int main() {
  2.     Node* head = NULL;
  3.     printList(head);
  4.  
  5.     // 在链表末尾插入节点
  6.     append(&head, 1);
  7.     append(&head, 2);
  8.     append(&head, 3);
  9.     printList(head);
  10.  
  11.     // 在指定位置插入节点
  12.     insert(&head, 4, 1);
  13.     printList(head);
  14.  
  15.     // 删除指定位置的节点
  16.     delete(&head, 2);
  17.     printList(head);
  18.  
  19.     return 0;
  20. }

​

        

h. 代码整合

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. // 双向链表节点结构
  5. typedef struct Node {
  6.     int data;
  7.     struct Node* prev;
  8.     struct Node* next;
  9. } Node;
  10.  
  11. // 创建一个新的节点
  12. Node* createNode(int data) {
  13.     Node* newNode = (Node*)malloc(sizeof(Node));
  14.     newNode->data = data;
  15.     newNode->prev = NULL;
  16.     newNode->next = NULL;
  17.     return newNode;
  18. }
  19.  
  20. // 在链表末尾插入节点
  21. void append(Node** head, int data) {
  22.     Node* newNode = createNode(data);
  23.     if (*head == NULL) {
  24.         *head = newNode;
  25.     } else {
  26.         Node* current = *head;
  27.         while (current->next != NULL) {
  28.             current = current->next;
  29.         }
  30.         current->next = newNode;
  31.         newNode->prev = current;
  32.     }
  33. }
  34.  
  35. // 在指定位置插入节点
  36. void insert(Node** head, int data, int position) {
  37.     Node* newNode = createNode(data);
  38.     if (position == 0) {
  39.         newNode->next = *head;
  40.         if (*head != NULL) {
  41.             (*head)->prev = newNode;
  42.         }
  43.         *head = newNode;
  44.     } else {
  45.         Node* current = *head;
  46.         int i;
  47.         for (i = 0; i < position - 1 && current != NULL; i++) {
  48.             current = current->next;
  49.         }
  50.         if (current == NULL) {
  51.             printf("Invalid position\n");
  52.             return;
  53.         }
  54.         newNode->next = current->next;
  55.         newNode->prev = current;
  56.         if (current->next != NULL) {
  57.             current->next->prev = newNode;
  58.         }
  59.         current->next = newNode;
  60.     }
  61. }
  62.  
  63. // 删除指定位置的节点
  64. void delete(Node** head, int position) {
  65.     if (*head == NULL) {
  66.         printf("List is empty\n");
  67.         return;
  68.     }
  69.     Node* temp = *head;
  70.     if (position == 0) {
  71.         *head = (*head)->next;
  72.         if (*head != NULL) {
  73.             (*head)->prev = NULL;
  74.         }
  75.         free(temp);
  76.     } else {
  77.         int i;
  78.         for (i = 0; i < position && temp != NULL; i++) {
  79.             temp = temp->next;
  80.         }
  81.         if (temp == NULL) {
  82.             printf("Invalid position\n");
  83.             return;
  84.         }
  85.         temp->prev->next = temp->next;
  86.         if (temp->next != NULL) {
  87.             temp->next->prev = temp->prev;
  88.         }
  89.         free(temp);
  90.     }
  91. }
  92.  
  93. // 遍历并打印链表
  94. void printList(Node* head) {
  95.     Node* current = head;
  96.     while (current != NULL) {
  97.         printf("%d ", current->data);
  98.         current = current->next;
  99.     }
  100.     printf("\n");
  101. }
  102.  
  103. // 主函数
  104. int main() {
  105.     Node* head = NULL;
  106.     printList(head);
  107.  
  108.     // 在链表末尾插入节点
  109.     append(&head, 1);
  110.     append(&head, 2);
  111.     append(&head, 3);
  112.     printList(head);
  113.  
  114.     // 在指定位置插入节点
  115.     insert(&head, 4, 1);
  116.     printList(head);
  117.  
  118.     // 删除指定位置的节点
  119.     delete(&head, 2);
  120.     printList(head);
  121.  
  122.     return 0;
  123. }

五、复杂性分析

        到目前为止，本系列已详细介绍了线性表的两种存储方式——顺序存储和链接存储，下面从空间和时间复杂性两方面对二者进行比较分析。

1. 空间效率比较

        顺序表所占用的空间来自于申请的数组空间，数组大小是事先确定的，很明显当表中的元素较少时，顺序表中的很多空间处于闲置状态，造成了空间的浪费；

        链表所占用的空间是根据需要动态申请的，不存在浪费空间的问题，但是链表需要在每个结点上附加一个指针域，从而增加一定的空间开销。

2. 时间效率比较

        线性表的基本操作是存取、插入和删除。对于顺序表，随机存取是非常容易的，但是每插入或删除一个元素，都需要移动若干元素。

        对于链表，无法实现随机存取，必须要从表头开始遍历链表，直到发现要存取的元素，但是链表的插入和删除操作却非常简便，只需要修改几个指针。

  • 当经常需要对线性表进行插入、删除操作时，链表的时间效率较高；
    • 双向链表在某些场景下更加灵活和高效，特别是需要频繁的插入和删除操作时。然而，在内存有限的情况下，单向链表可能更为合适。
  • 当经常需要对线性表进行存取且存取操作比插入、删除操作更为频繁时，顺序表的时间效率较高

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

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

  

闽ICP备14008679号