• 【数据结构】线性表（二）单链表及其基本操作（创建、插入、删除、修改、遍历打印）

    目录

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

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

    1. 单链表（C语言）

    a. 链表节点结构

    b. 创建新节点

    c. 在链表末尾插入新节点

    d. 删除指定节点

    e. 修改指定节点的数据

    f. 遍历链表并打印

    g. 主函数

    C语言代码整合

    Cpp代码整合

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

            按照线性表结点间的逻辑顺序依次将它们存储于一组地址连续的存储单元中的存储方式被称为线性表的顺序存储方式。

            按顺序存储方式存储的线性表具有顺序存储结构，一般称之为顺序表。换言之，在程序中采用定长的一维数组，按照顺序存储方式存储的线性表，被称为顺序表。若顺序表中的元素按其值有序，则称其为有序顺序表。

            在高级程序设计语言中，“数组”这种数据类型同样具有随机存储的特性，因此用高级程序设计语言实现线性表的顺序存储结构时，通常选择数组。因此，数组的长度就是顺序表的最大长度（MaxSize），顺序表的实际长度为length，其值必须小于等于MaxSize。

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

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

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

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

    1. 单链表（C语言）

            在链接存储结构中，插入和删除操作相对于顺序存储结构而言更加高效，时间复杂度为O(1)。而查找操作的时间复杂度为O(n)。

    a. 链表节点结构

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

            链表节点的结构体 Node，包含一个整数数据 data 和一个指向下一个节点的指针 next

    b. 创建新节点

    1. Node* createNode(int data) {
    2.     Node* newNode = (Node*)malloc(sizeof(Node));
    3.     if (newNode != NULL) {
    4.         newNode->data = data;
    5.         newNode->next = NULL;
    6.     }
    7.     return newNode;
    8. }
    • 创建一个新的节点并返回指向该节点的指针：
      • 使用 malloc 分配了节点的内存空间；
      • 将传入的数据赋值给节点的 data 字段，并将 next 字段设置为 NULL。

    c. 在链表末尾插入新节点

    1. void insertAtEnd(Node** head, int data) {
    2.     Node* newNode = createNode(data);
    3.     if (newNode == NULL) {
    4.         printf("内存分配失败！\n");
    5.         return;
    6.     }
    7.  
    8.     if (*head == NULL) {
    9.         *head = newNode;
    10.     } else {
    11.         Node* temp = *head;
    12.         while (temp->next != NULL) {
    13.             temp = temp->next;
    14.         }
    15.         temp->next = newNode;
    16.     }
    17.     printf("已在链表末尾插入节点：%d", data);
    18. }
    • 调用 createNode 函数创建一个新节点；
    • 检查内存分配是否成功；
      • 如果成功，则根据链表是否为空来确定新节点的位置。
    • 若链表为空，则将新节点设置为头节点；
    • 否则，遍历链表找到最后一个节点，并将最后一个节点的 next 指针指向新节点。

    d. 删除指定节点

    1. void deleteNode(Node** head, int data) {
    2.     if (*head == NULL) {
    3.         printf("链表为空！\n");
    4.         return;
    5.     }
    6.  
    7.     Node* temp = *head;
    8.     Node* prev = NULL;
    9.  
    10.     if (temp != NULL && temp->data == data) {
    11.         *head = temp->next;
    12.         free(temp);
    13.         printf("已删除节点：%d", data);
    14.         return;
    15.     }
    16.  
    17.     while (temp != NULL && temp->data != data) {
    18.         prev = temp;
    19.         temp = temp->next;
    20.     }
    21.  
    22.     if (temp == NULL) {
    23.         printf("节点 %d 不存在！\n", data);
    24.         return;
    25.     }
    26.  
    27.     prev->next = temp->next;
    28.     free(temp);
    29.     printf("已删除节点：%d", data);
    30. }
    • 检查链表是否为空，如果为空则输出相应的提示信息。
    • 遍历链表，找到要删除的节点。
      • 如果找到了节点，则修改前一个节点的 next 指针，使其跳过要删除的节点，并释放该节点的内存空间。
      • 如果没有找到要删除的节点，则输出相应的提示信息。

    e. 修改指定节点的数据

    1. void modifyNode(Node* head, int oldData, int newData) {
    2.     if (head == NULL) {
    3.         printf("链表为空！\n");
    4.         return;
    5.     }
    6.  
    7.     Node* temp = head;
    8.     while (temp != NULL) {
    9.         if (temp->data == oldData) {
    10.             temp->data = newData;
    11.             printf("已将节点 %d 修改为 %d\n", oldData, newData);
    12.             return;
    13.         }
    14.         temp = temp->next;
    15.     }
    16.  
    17.     printf("节点 %d 不存在！\n", oldData);
    18. }

    查找~删除~修改……这里不重复介绍，懂的都懂，不懂我也没办法

    f. 遍历链表并打印

    1. void printList(Node* head) {
    2.     if (head == NULL) {
    3.         printf("链表为空！\n");
    4.         return;
    5.     }
    6.  
    7.     Node* temp = head;
    8.     printf("链表节点数据：");
    9.     while (temp != NULL) {
    10.         printf("%d ", temp->data);
    11.         temp = temp->next;
    12.     }
    13.     printf("\n");
    14. }
    • 检查链表是否为空，如果为空则输出相应的提示信息。
    • 使用一个临时指针变量 temp 来遍历链表，依次访问每个节点并打印其数据。

    g. 主函数

    1. nt main() {
    2.     Node* head = NULL;  // 头节点
    3.  
    4.     insertAtEnd(&head, 1);
    5.     insertAtEnd(&head, 2);
    6.     insertAtEnd(&head, 3);
    7.  
    8.     printList(head);
    9.  
    10.     deleteNode(&head, 2);
    11.  
    12.     printList(head);
    13.  
    14.     deleteNode(&head, 4);
    15.  
    16.     return 0;
    17. }
    • 创建了一个头节点 head；
    • 调用 insertAtEnd 函数三次，在链表末尾插入了三个节点；
    • 调用 printList 函数打印链表的节点数据；
    • 调用 deleteNode 函数删除链表中的一个节点，并再次打印链表的节点数据；
    • 调用 deleteNode 函数尝试删除一个不存在的节点。

    C语言代码整合

    1. #include 
    2. #include 
    3.  
    4. // 定义链表节点结构
    5. typedef struct Node {
    6.     int data;
    7.     struct Node* next;
    8. } Node;
    9.  
    10. // 创建新节点
    11. Node* createNode(int data) {
    12.     Node* newNode = (Node*)malloc(sizeof(Node));
    13.     if (newNode != NULL) {
    14.         newNode->data = data;
    15.         newNode->next = NULL;
    16.     }
    17.     return newNode;
    18. }
    19.  
    20. // 在链表末尾插入新节点
    21. void insertAtEnd(Node** head, int data) {
    22.     Node* newNode = createNode(data);
    23.     if (newNode == NULL) {
    24.         printf("内存分配失败！\n");
    25.         return;
    26.     }
    27.  
    28.     if (*head == NULL) {
    29.         *head = newNode;
    30.     } else {
    31.         Node* temp = *head;
    32.         while (temp->next != NULL) {
    33.             temp = temp->next;
    34.         }
    35.         temp->next = newNode;
    36.     }
    37.     printf("已在链表末尾插入节点：%d", data);
    38. }
    39.  
    40. // 删除指定节点
    41. void deleteNode(Node** head, int data) {
    42.     if (*head == NULL) {
    43.         printf("链表为空！\n");
    44.         return;
    45.     }
    46.  
    47.     Node* temp = *head;
    48.     Node* prev = NULL;
    49.  
    50.     if (temp != NULL && temp->data == data) {
    51.         *head = temp->next;
    52.         free(temp);
    53.         printf("已删除节点：%d", data);
    54.         return;
    55.     }
    56.  
    57.     while (temp != NULL && temp->data != data) {
    58.         prev = temp;
    59.         temp = temp->next;
    60.     }
    61.  
    62.     if (temp == NULL) {
    63.         printf("节点 %d 不存在！\n", data);
    64.         return;
    65.     }
    66.  
    67.     prev->next = temp->next;
    68.     free(temp);
    69.     printf("已删除节点：%d", data);
    70. }
    71. // 修改指定节点的数据
    72. void modifyNode(Node* head, int oldData, int newData) {
    73.     if (head == NULL) {
    74.         printf("链表为空！\n");
    75.         return;
    76.     }
    77.  
    78.     Node* temp = head;
    79.     while (temp != NULL) {
    80.         if (temp->data == oldData) {
    81.             temp->data = newData;
    82.             printf("已将节点 %d 修改为 %d\n", oldData, newData);
    83.             return;
    84.         }
    85.         temp = temp->next;
    86.     }
    87.  
    88.     printf("节点 %d 不存在！\n", oldData);
    89. }
    90. // 遍历链表并打印节点数据
    91. void printList(Node* head) {
    92.     if (head == NULL) {
    93.         printf("链表为空！\n");
    94.         return;
    95.     }
    96.  
    97.     Node* temp = head;
    98.     printf("链表节点数据：");
    99.     while (temp != NULL) {
    100.         printf("%d ", temp->data);
    101.         temp = temp->next;
    102.     }
    103.     printf("\n");
    104. }
    105.  
    106. // 主函数测试链表操作
    107. int main() {
    108.     Node* head = NULL;  // 头节点
    109.  
    110.     insertAtEnd(&head, 1);
    111.     insertAtEnd(&head, 2);
    112.     insertAtEnd(&head, 3);
    113.  
    114.     printList(head);
    115.  
    116.     deleteNode(&head, 2);
    117.  
    118.     printList(head);
    119.  
    120.     deleteNode(&head, 4);
    121.  
    122.     return 0;
    123. }

    Cpp代码整合

            与C语言基本相同，这里不再过多介绍

    1. #include 
    2.  
    3. // 定义链表节点结构
    4. class Node {
    5. public:
    6.     int data;
    7.     Node* next;
    8.  
    9.     // 构造函数
    10.     Node(int data) : data(data), next(nullptr) {}
    11. };
    12.  
    13. // 链表类
    14. class LinkedList {
    15. private:
    16.     Node* head;
    17.  
    18. public:
    19.     // 构造函数
    20.     LinkedList() : head(nullptr) {}
    21.  
    22.     // 析构函数，用于释放链表内存
    23.     ~LinkedList() {
    24.         Node* current = head;
    25.         while (current != nullptr) {
    26.             Node* next = current->next;
    27.             delete current;
    28.             current = next;
    29.         }
    30.     }
    31.  
    32.     // 在链表末尾插入新节点
    33.     void insertAtEnd(int data) {
    34.         Node* newNode = new Node(data);
    35.  
    36.         if (head == nullptr) {
    37.             head = newNode;
    38.         } else {
    39.             Node* temp = head;
    40.             while (temp->next != nullptr) {
    41.                 temp = temp->next;
    42.             }
    43.             temp->next = newNode;
    44.         }
    45.         std::cout << "已在链表末尾插入节点：" << data << std::endl;
    46.     }
    47.  
    48.     // 删除指定节点
    49.     void deleteNode(int data) {
    50.         if (head == nullptr) {
    51.             std::cout << "链表为空！" << std::endl;
    52.             return;
    53.         }
    54.  
    55.         Node* temp = head;
    56.         Node* prev = nullptr;
    57.  
    58.         if (temp != nullptr && temp->data == data) {
    59.             head = temp->next;
    60.             delete temp;
    61.             std::cout << "已删除节点：" << data << std::endl;
    62.             return;
    63.         }
    64.  
    65.         while (temp != nullptr && temp->data != data) {
    66.             prev = temp;
    67.             temp = temp->next;
    68.         }
    69.  
    70.         if (temp == nullptr) {
    71.             std::cout << "节点 " << data << " 不存在！" << std::endl;
    72.             return;
    73.         }
    74.  
    75.         prev->next = temp->next;
    76.         delete temp;
    77.         std::cout << "已删除节点：" << data << std::endl;
    78.     }
    79.  
    80.     // 修改指定节点的数据
    81.     void modifyNode(int oldData, int newData) {
    82.         if (head == nullptr) {
    83.             std::cout << "链表为空！" << std::endl;
    84.             return;
    85.         }
    86.  
    87.         Node* temp = head;
    88.         while (temp != nullptr) {
    89.             if (temp->data == oldData) {
    90.                 temp->data = newData;
    91.                 std::cout << "已将节点 " << oldData << " 修改为 " << newData << std::endl;
    92.                 return;
    93.             }
    94.             temp = temp->next;
    95.         }
    96.  
    97.         std::cout << "节点 " << oldData << " 不存在！" << std::endl;
    98.     }
    99.  
    100.     // 遍历链表并打印节点数据
    101.     void printList() {
    102.         if (head == nullptr) {
    103.             std::cout << "链表为空！" << std::endl;
    104.             return;
    105.         }
    106.  
    107.         Node* temp = head;
    108.         std::cout << "链表节点数据：";
    109.         while (temp != nullptr) {
    110.             std::cout << temp->data << " ";
    111.             temp = temp->next;
    112.         }
    113.         std::cout << std::endl;
    114.     }
    115. };
    116.  
    117. int main() {
    118.     LinkedList list;
    119.  
    120.     list.insertAtEnd(1);
    121.     list.insertAtEnd(2);
    122.     list.insertAtEnd(3);
    123.  
    124.     list.printList();
    125.  
    126.     list.deleteNode(2);
    127.  
    128.     list.printList();
    129.  
    130.     list.deleteNode(4);
    131.  
    132.     return 0;
    133. }

  • 相关阅读:
    《向量数据库指南》——TruLens 用于语言模型应用跟踪和评估
    详解GDAL (Python)读写栅格数据
    拍卖许可证
    frp隧道（流量代理）
    自学（黑客）技术方法————网络安全
    （原创）【MAUI】一步一步实现“悬浮操作按钮”（FAB，Floating Action Button）
    猿创征文｜从JAVAER到GISER的进击之路
    腾讯员工被曝偷看创业公司工作文档；iOS 15.4.1修复耗电过快问题；Spring承认RCE大漏洞|极客头条
    AC-PEG-NH2，Acrylate-PEG-Amine，丙烯酸酯PEG氨基含有PEG间隔基
    Istio微服务治理网格流量管理核心资源控制器详解
  • 原文地址：https://blog.csdn.net/m0_63834988/article/details/133914875