• 【数据结构】线性表（三）循环链表的各种操作（创建、插入、查找、删除、修改、遍历打印、释放内存空间）

    目录

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

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

    1. 单链表

    2. 循环链表

    a. 循环链表节点结构体

    b. 创建新节点

    c. 在循环链表末尾插入节点

    d. 删除循环链表中指定值的节点

    e. 在循环链表中查找指定值的节点

    f. 修改循环链表中指定节点的值

    g. 打印循环链表

    h. 释放循环链表内存空间

    i. 主函数

    j. 代码整合

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

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

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

    【数据结构】线性表（一）线性表的定义及其基本操作（顺序表插入、删除、查找、修改）-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，这样的单链表被称为循环链表。循环链表使用户可以从链表的任何位置开始，访问链表中的任意结点。

    a. 循环链表节点结构体

    1. typedef struct Node {
    2.     int data;           // 数据域
    3.     struct Node *next;  // 指针域
    4. } Node;

            包含一个整型数据域 data 和一个指向下一个节点的指针域 next。

    b. 创建新节点

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

    c. 在循环链表末尾插入节点

    1. void insert(Node** head, int data) {
    2.     Node* newNode = createNode(data);
    3.  
    4.     if (*head == NULL) {
    5.         *head = newNode;
    6.         (*head)->next = *head;  // 将尾节点指向头节点，形成循环
    7.     } else {
    8.         Node* temp = *head;
    9.         while (temp->next != *head) {
    10.             temp = temp->next;
    11.         }
    12.         temp->next = newNode;
    13.         newNode->next = *head;
    14.     }
    15. }
    • 调用 createNode 函数创建一个新节点，并将新节点的指针保存在 newNode 中。
    • 检查链表是否为空
      • 如果为空，则将 head 指向新节点，并将新节点的指针域 next 设置为指向自己，这样形成一个只有一个节点的循环链表。
      • 如果链表不为空，遍历链表找到尾节点，将尾节点的指针域 next 指向新节点，新节点的指针域 next 指向头节点，完成节点的插入操作。

    d. 删除循环链表中指定值的节点

    1. void deleteNode(Node** head, int data) {
    2.     if (*head == NULL) {
    3.         return;
    4.     }
    5.  
    6.     Node* currNode = *head;
    7.     Node* prevNode = NULL;
    8.  
    9.     while (currNode->next != *head) {
    10.         if (currNode->data == data) {
    11.             if (prevNode == NULL) {
    12.                 Node* lastNode = *head;
    13.                 while (lastNode->next != *head) {
    14.                     lastNode = lastNode->next;
    15.                 }
    16.                 *head = currNode->next;
    17.                 lastNode->next = *head;
    18.             } else {
    19.                 prevNode->next = currNode->next;
    20.             }
    21.             free(currNode);
    22.             return;
    23.         }
    24.  
    25.         prevNode = currNode;
    26.         currNode = currNode->next;
    27.     }
    28.  
    29.     if (currNode->data == data) {
    30.         if (prevNode == NULL) {
    31.             *head = NULL;
    32.         } else {
    33.             prevNode->next = *head;
    34.         }
    35.         free(currNode);
    36.     }
    37. }
    • 检查链表是否为空，如果为空则直接返回。
    • 定义两个指针 currNode 和 prevNode
      • currNode 指向当前节点，初始时指向头节点
      • prevNode指向前一个节点，初始为 NULL
    • 遍历链表，如果找到了与指定值相等的节点，则判断该节点是否为头节点，
      • 如果是头节点，则需要找到尾节点将其指向新的头节点，并更新 *head 的值为删除节点的下一个节点，最后释放删除节点的内存。
      • 如果不是头节点，直接将前一个节点的指针域 next 指向删除节点的下一个节点，然后释放删除节点的内存。

    e. 在循环链表中查找指定值的节点

    1. Node* search(Node* head, int data) {
    2.     if (head == NULL) {
    3.         return NULL;
    4.     }
    5.  
    6.     Node* currNode = head;
    7.  
    8.     while (currNode->next != head) {
    9.         if (currNode->data == data) {
    10.             return currNode;
    11.         }
    12.         currNode = currNode->next;
    13.     }
    14.  
    15.     if (currNode->data == data) {
    16.         return currNode;
    17.     }
    18.  
    19.     return NULL;
    20. }
    • 链表是否为空，如果为空则返回 NULL。
    • 定义一个指针 currNode，初始时指向头节点。
    • 遍历链表，如果找到了与指定值相等的节点，则返回该节点的指针。
    • 如果遍历完整个链表都没找到相等的节点，则返回 NULL。

    f. 修改循环链表中指定节点的值

    1. void modify(Node* head, int oldData, int newData) {
    2.     Node* nodeToModify = search(head, oldData);
    3.  
    4.     if (nodeToModify != NULL) {
    5.         nodeToModify->data = newData;
    6.     }
    7. }
    • 调用上述e中 search 函数查找指定值的节点，并将返回的节点指针保存在 nodeToModify 中
    • 如果找到了节点，则将该节点的数据域 data 更新为 newData。

    g. 打印循环链表

    1. void printList(Node* head) {
    2.     if (head == NULL) {
    3.         printf("循环链表为空\n");
    4.         return;
    5.     }
    6.  
    7.     Node* currNode = head;
    8.  
    9.     do {
    10.         printf("%d ", currNode->data);
    11.         currNode = currNode->next;
    12.     } while (currNode != head);
    13.  
    14.     printf("\n");
    15. }
    • 检查链表是否为空，如果为空则打印提示信息并返回。
    • 定义一个指针 currNode，初始时指向头节点。
    • 使用 do-while 循环遍历链表，打印当前节点的数据，然后将指针移动到下一个节点，直到回到头节点为止。

    h. 释放循环链表内存空间

    1. void freeList(Node** head) {
    2.     if (*head == NULL) {
    3.         return;
    4.     }
    5.  
    6.     Node* currNode = *head;
    7.     Node* nextNode = NULL;
    8.  
    9.     while (currNode->next != *head) {
    10.         nextNode = currNode->next;
    11.         free(currNode);
    12.         currNode = nextNode;
    13.     }
    14.  
    15.     free(currNode);
    16.     *head = NULL;
    17. }
    • 检查链表是否为空，如果为空则直接返回。
    • 定义两个指针 currNode 和 nextNode
      • currNode 指向当前节点，初始时指向头节点
      • nextNode指向下一个节点，初始为 NULL
    • 使用 while 循环遍历链表，将 nextNode 指向 currNode 的下一个节点，释放 currNode 指向的节点的内存，然后将 currNode 更新为 nextNode。重复以上步骤，直到遍历完整个链表，并最后释放头节点的内存。

    i. 主函数

    1. int main() {
    2.     Node* head = NULL;
    3.  
    4.     // 在循环链表中插入节点
    5.     insert(&head, 10);
    6.     insert(&head, 20);
    7.     insert(&head, 30);
    8.     insert(&head, 40);
    9.  
    10.     // 打印循环链表
    11.     printf("循环链表: ");
    12.     printList(head);
    13.  
    14.     // 删除循环链表中的节点
    15.     deleteNode(&head, 20);
    16.  
    17.     // 打印删除节点后的循环链表
    18.     printf("删除节点后的循环链表: ");
    19.     printList(head);
    20.  
    21.     // 在循环链表中查找节点
    22.     Node* searchResult = search(head, 30);
    23.     if (searchResult != NULL) {
    24.         printf("找到节点 %d\n", searchResult->data);
    25.     } else {
    26.         printf("未找到节点\n");
    27.     }
    28.  
    29.     // 修改循环链表中的节点值
    30.     modify(head, 30, 50);
    31.  
    32.     // 打印修改节点值后的循环链表
    33.     printf("修改节点值后的循环链表: ");
    34.     printList(head);
    35.  
    36.     // 释放循环链表内存空间
    37.     freeList(&head);
    38.  
    39.     return 0;
    40. }
    • 定义一个指向头节点的指针 head，初始时为 NULL。
    • 通过调用 insert 函数，在循环链表中插入了四个节点，其数据分别为 10、20、30 和 40。
    • 调用 deleteNode 函数删除了值为 20 的节点，并再次调用 printList 函数打印删除节点后的循环链表。
    • 调用 search 函数查找值为 30 的节点，并根据返回结果打印相应的信息。
    • 调用 modify 函数修改值为 30 的节点的数据为 50，
    • 最后调用 freeList 函数释放循环链表占用的内存空间。

    j. 代码整合

    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.     newNode->data = data;
    14.     newNode->next = NULL;
    15.     return newNode;
    16. }
    17.  
    18. // 在循环链表末尾插入节点
    19. void insert(Node** head, int data) {
    20.     Node* newNode = createNode(data);
    21.  
    22.     if (*head == NULL) {
    23.         *head = newNode;
    24.         (*head)->next = *head;  // 将尾节点指向头节点，形成循环
    25.     } else {
    26.         Node* temp = *head;
    27.         while (temp->next != *head) {
    28.             temp = temp->next;
    29.         }
    30.         temp->next = newNode;
    31.         newNode->next = *head;
    32.     }
    33. }
    34.  
    35. // 删除循环链表中指定值的节点
    36. void deleteNode(Node** head, int data) {
    37.     if (*head == NULL) {
    38.         return;
    39.     }
    40.  
    41.     Node* currNode = *head;
    42.     Node* prevNode = NULL;
    43.  
    44.     while (currNode->next != *head) {
    45.         if (currNode->data == data) {
    46.             if (prevNode == NULL) {
    47.                 Node* lastNode = *head;
    48.                 while (lastNode->next != *head) {
    49.                     lastNode = lastNode->next;
    50.                 }
    51.                 *head = currNode->next;
    52.                 lastNode->next = *head;
    53.             } else {
    54.                 prevNode->next = currNode->next;
    55.             }
    56.             free(currNode);
    57.             return;
    58.         }
    59.  
    60.         prevNode = currNode;
    61.         currNode = currNode->next;
    62.     }
    63.  
    64.     if (currNode->data == data) {
    65.         if (prevNode == NULL) {
    66.             *head = NULL;
    67.         } else {
    68.             prevNode->next = *head;
    69.         }
    70.         free(currNode);
    71.     }
    72. }
    73.  
    74. // 在循环链表中查找指定值的节点
    75. Node* search(Node* head, int data) {
    76.     if (head == NULL) {
    77.         return NULL;
    78.     }
    79.  
    80.     Node* currNode = head;
    81.  
    82.     while (currNode->next != head) {
    83.         if (currNode->data == data) {
    84.             return currNode;
    85.         }
    86.         currNode = currNode->next;
    87.     }
    88.  
    89.     if (currNode->data == data) {
    90.         return currNode;
    91.     }
    92.  
    93.     return NULL;
    94. }
    95.  
    96. // 修改循环链表中指定节点的值
    97. void modify(Node* head, int oldData, int newData) {
    98.     Node* nodeToModify = search(head, oldData);
    99.  
    100.     if (nodeToModify != NULL) {
    101.         nodeToModify->data = newData;
    102.     }
    103. }
    104.  
    105. // 打印循环链表
    106. void printList(Node* head) {
    107.     if (head == NULL) {
    108.         printf("循环链表为空\n");
    109.         return;
    110.     }
    111.  
    112.     Node* currNode = head;
    113.  
    114.     do {
    115.         printf("%d ", currNode->data);
    116.         currNode = currNode->next;
    117.     } while (currNode != head);
    118.  
    119.     printf("\n");
    120. }
    121.  
    122. // 释放循环链表内存空间
    123. void freeList(Node** head) {
    124.     if (*head == NULL) {
    125.         return;
    126.     }
    127.  
    128.     Node* currNode = *head;
    129.     Node* nextNode = NULL;
    130.  
    131.     while (currNode->next != *head) {
    132.         nextNode = currNode->next;
    133.         free(currNode);
    134.         currNode = nextNode;
    135.     }
    136.  
    137.     free(currNode);
    138.     *head = NULL;
    139. }
    140.  
    141. int main() {
    142.     Node* head = NULL;
    143.  
    144.     // 在循环链表中插入节点
    145.     insert(&head, 10);
    146.     insert(&head, 20);
    147.     insert(&head, 30);
    148.     insert(&head, 40);
    149.  
    150.     // 打印循环链表
    151.     printf("循环链表: ");
    152.     printList(head);
    153.  
    154.     // 删除循环链表中的节点
    155.     deleteNode(&head, 20);
    156.  
    157.     // 打印删除节点后的循环链表
    158.     printf("删除节点后的循环链表: ");
    159.     printList(head);
    160.  
    161.     // 在循环链表中查找节点
    162.     Node* searchResult = search(head, 30);
    163.     if (searchResult != NULL) {
    164.         printf("找到节点 %d\n", searchResult->data);
    165.     } else {
    166.         printf("未找到节点\n");
    167.     }
    168.  
    169.     // 修改循环链表中的节点值
    170.     modify(head, 30, 50);
    171.  
    172.     // 打印修改节点值后的循环链表
    173.     printf("修改节点值后的循环链表: ");
    174.     printList(head);
    175.  
    176.     // 释放循环链表内存空间
    177.     freeList(&head);
    178.  
    179.     return 0;
    180. }

  • 相关阅读:
    Flink入门
    torchvision.models中模型编辑的requires_grad
    zookeeper的watch机制详细讲解
    抖音短视频怎么做——今抖云创
    php-fpm 讲解
    AUTOSAR汽车电子嵌入式编程精讲300篇-面向OTA的信息安全防护协议
    失落的方舟台服预下载教程 一键下载＋账号注册教程
    从零到上亿用户，我是如何一步步优化MySQL数据库的？（建议收藏）
    Linux应用-ElasticSearch安装
    部署kubernetes-v1.25.3（k8s）- 基于containerd容器运行时
  • 原文地址：https://blog.csdn.net/m0_63834988/article/details/133914085