详解循环链表

最新推荐文章于 2024-04-07 11:30:50 发布
最新推荐文章于 2024-04-07 11:30:50 发布
阅读量122 收藏
点赞数
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65087192/article/details/133843313
版权

定义

循环链表是一种链表，其中最后一个节点的指针指向第一个节点，形成一个环形结构。

特点

  1. 最后一个节点的指针指向第一个节点，形成一个环形结构。
  2. 可以通过任意一个节点遍历整个链表。
  3. 插入和删除节点时，需要特别注意头节点和尾节点的处理等。

循环链表操作

  1. 头节点
  2. 尾节点
  3. 指定位置插入
  4. 删除元素
  5. 查找元素
  6. 遍历输出链表

循环链表的实现

 初始化链表

typedef struct Node {
    int data;
    struct Node* next;
} Node;

// 初始化链表
void initialize(Node** head) {
    *head = NULL;
}

 头插法插入节点

// 头插法插入节点
void insertAtHead(Node** head, int value) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = value;

    if (*head == NULL) {
        *head = newNode;
        newNode->next = *head;
    }
    else {
        Node* current = *head;
        while (current->next != *head) {
            current = current->next;
        }
        newNode->next = *head;
        current->next = newNode;
        *head = newNode;
    }
}

尾插法插入节点

// 尾插法插入节点
void insertAtTail(Node** head, int value) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = value;

    if (*head == NULL) {
        *head = newNode;
        newNode->next = *head;
    }
    else {
        Node* current = *head;
        while (current->next != *head) {
            current = current->next;
        }
        current->next = newNode;
        newNode->next = *head;
    }
}

 在位置i插入元素

// 在位置i插入元素
void insertAtPosition(Node** head, int value, int position) {
    int length = getLength(*head);

    if (position < 0 || position > length) {
        printf("无效的位置\n");
        return;
    }

    if (position == 0) {
        insertAtHead(head, value);
    }
    else if (position == length) {
        insertAtTail(head, value);
    }
    else {
        Node* newNode = (Node*)malloc(sizeof(Node));
        newNode->data = value;

        Node* current = *head;
        int i = 0;
        while (i < position - 1) {
            current = current->next;
            i++;
        }

        newNode->next = current->next;
        current->next = newNode;
    }
}

运行结果

 

 

删除元素

// 删除元素
void delete(Node** head, int value) {
    if (*head == NULL) {
        printf("链表为空\n");
        return;
    }

    Node* temp = *head;
    Node* prev = NULL;

    do {
        if (temp->data == value) {
            if (temp == *head) {
                *head = temp->next;
            }
            prev->next = temp->next;
            free(temp);
            return;
        }
        prev = temp;
        temp = temp->next;
    } while (temp != *head);

    printf("链表中没有该元素\n");
}

运行结果

 

 

查找元素

// 查找元素
int search(Node* head, int value) {
    if (head == NULL) {
        printf("链表为空\n");
        return 0;
    }

    Node* current = head;

    do {
        if (current->data == value) {
            return 1;
        }
        current = current->next;
    } while (current != head);

    return 0;
}

遍历输出链表

// 遍历链表
void traverse(Node* head) {
    if (head == NULL) {
        printf("链表为空\n");
        return;
    }

    Node* current = head;

    do {
        printf("%d ", current->data);
        current = current->next;
    } while (current != head);

    printf("\n");
}

 

 

完整的Demo

#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
    int data;
    struct Node* next;
} Node;

// 初始化链表
void initialize(Node** head) {
    *head = NULL;
}

// 获取链表长度
int getLength(Node* head) {
    int length = 0;
    Node* current = head;
    
    if (head == NULL) {
        return length;
    }
    
    do {
        length++;
        current = current->next;
    } while (current != head);
    
    return length;
}

// 头插法插入节点
void insertAtHead(Node** head, int value) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = value;
    
    if (*head == NULL) {
        *head = newNode;
        newNode->next = *head;
    } else {
        Node* current = *head;
        while (current->next != *head) {
            current = current->next;
        }
        newNode->next = *head;
        current->next = newNode;
        *head = newNode;
    }
}

// 尾插法插入节点
void insertAtTail(Node** head, int value) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = value;
    
    if (*head == NULL) {
        *head = newNode;
        newNode->next = *head;
    } else {
        Node* current = *head;
        while (current->next != *head) {
            current = current->next;
        }
        current->next = newNode;
        newNode->next = *head;
    }
}

// 在位置i插入元素
void insertAtPosition(Node** head, int value, int position) {
    int length = getLength(*head);
    
    if (position < 0 || position > length) {
        printf("无效的位置\n");
        return;
    }
    
    if (position == 0) {
        insertAtHead(head, value);
    } else if (position == length) {
        insertAtTail(head, value);
    } else {
        Node* newNode = (Node*)malloc(sizeof(Node));
        newNode->data = value;
        
        Node* current = *head;
        int i = 0;
        while (i < position - 1) {
            current = current->next;
            i++;
        }
        
        newNode->next = current->next;
        current->next = newNode;
    }
}

// 删除元素
void delete(Node** head, int value) {
    if (*head == NULL) {
        printf("链表为空\n");
        return;
    }
    
    Node* temp = *head;
    Node* prev = NULL;
    
    do {
        if (temp->data == value) {
            if (temp == *head) {
                *head = temp->next;
            }
            prev->next = temp->next;
            free(temp);
            return;
        }
        prev = temp;
        temp = temp->next;
    } while (temp != *head);
    
    printf("链表中没有该元素\n");
}

// 查找元素
int search(Node* head, int value) {
    if (head == NULL) {
        printf("链表为空\n");
        return 0;
    }
    
    Node* current = head;
    
    do {
        if (current->data == value) {
            return 1;
        }
        current = current->next;
    } while (current != head);
    
    return 0;
}

// 遍历链表
void traverse(Node* head) {
    if (head == NULL) {
        printf("链表为空\n");
        return;
    }
    
    Node* current = head;
    
    do {
        printf("%d ", current->data);
        current = current->next;
    } while (current != head);
    
    printf("\n");
}

int main() {
    Node* head;
    int choice, value, position;
    
    initialize(&head);
    
    while(1) {
        printf("1. 头插法插入节点\n");
        printf("2. 尾插法插入节点\n");
        printf("3. 在位置i插入元素\n");
        printf("4. 删除元素\n");
        printf("5. 查找元素\n");
        printf("6. 输出链表\n");
        printf("0. 退出程序\n");
        printf("请输入你的选择：");
        scanf("%d", &choice);
        
        switch(choice) {
            case 1:
                printf("请输入要插入的节点值：");
                scanf("%d", &value);
                insertAtHead(&head, value);
                break;
            case 2:
                printf("请输入要插入的节点值：");
                scanf("%d", &value);
                insertAtTail(&head, value);
                break;
            case 3:
                printf("请输入要插入的节点值：");
                scanf("%d", &value);
                printf("请输入要插入的位置：");
                scanf("%d", &position);
                insertAtPosition(&head, value, position);
                break;
            case 4:
                printf("请输入要删除的节点值：");
                scanf("%d", &value);
                delete(&head, value);
                break;
            case 5:
                printf("请输入要查找的节点值：");
                scanf("%d", &value);
                if (search(head, value)) {
                    printf("链表中存在该元素\n");
                } else {
                    printf("链表中不存在该元素\n");
                }
                break;
            case 6:
                traverse(head);
                break;
            case 0:
                exit(0);
            default:
                printf("无效的选择\n");
        }
    }
    
    return 0;
}

小结

  1. 循环链表是一种特殊的链表，它的最后一个节点指向头节点，形成一个循环的环状结构。
  2. 循环链表可以通过头指针来访问链表的任意位置，而不仅仅是从头节点开始。
  3. 插入节点的操作和普通链表类似，可以在链表的头部、尾部或指定位置插入节点。
  4. 删除节点的操作也与普通链表类似，可以根据节点的值来删除节点。
  5. 查找节点的操作也与普通链表类似，可以根据节点的值来查找节点是否存在。
  6. 遍历循环链表时，需要注意循环的终止条件，即当遍历到头节点时结束循环。

参考资料

主要参考各种搜索引擎及AI

xxdillon
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
循环双链表详解
Arrow的博客
03-20 7188
循环双链表创建以及排序 1. 创建双链表 完整代码如下 #include<stdio.h> #include<stdlib.h> typedef struct node { int data; struct node *nex; struct node *pre; }NODE; void Add_Data(NODE*,int)； int main() ...
循环链表
a4647520的专栏
08-12 546
单链的循环链表结点的存储结构和单链表的存储结构一样，所不同的是：最后一个结 点的next 域指向头结点，而不是“空”。这样，由表尾很容易找到表头。但若链表较长， 则由表头找到表尾较费时，因而，单循环链表往往设立尾指针而不是头指针，如图231 所示。这在两个链表首尾相连合并成一个链表时非常方便。Bo2-4.cpp 是设立尾指针的单 循环链表的基本操作。
C语言数据结构之循环链表
m0_58303983的博客
10-15 524
指针域至少包括一个指向下一个节点的指针，一个指向前一个节点的指针（在第一个节点中为NULL），以及一个指向链表头节点的指针。将要删除的节点的prev指针的next指针指向要删除的节点的next指针所指向的节点；将要删除的节点的next指针的prev指针指向要删除的节点的prev指针所指向的节点；将头节点的prev指针的next指针指向头节点的next指针所指向的节点；将头节点的next指针的prev指针指向头节点的prev指针所指向的节点；将前一个节点的next指针指向新节点的next指针所指向的节点。
链接表操作：遍历、插入和删除
ntr851217的博客
08-07 1394
什么是链表？链表是一种线性数据结构，包括一系列相连的结点。在这里，每个节点都存储数据和下一个节点的地址。例如：链表有多种类型：单链表、双链表和循环链表。这里仅介绍单链表。
数据结构——循环链表
zhang_ysx的博客
01-10 2796
循环链表的简单操作
链表基本操作（详解）
Czc1357618897的博客
11-30 1万+
链表的基本操作 这里写目录标题链表的基本操作一：单链表的基础知识二：单链表的建立头插法尾插法三：单链表的遍历四：单链表结点数目判断五：单链表的插入链表头插入任意结点插入链表尾部插入六：单链表的删除七 ：单链表的查询 一：单链表的基础知识 为什么需要链表？ 我们在使用数组存放数据是非常方便，但是由于数组的长度是固定的，所以当存储不同的元素数量时，就很容易出现问题。如果向数组中添加的数量大于数组大小时候，信息无法完全被保存。所以我们需要另一种存储方式来存储数据，其中存储的元素的个数不受限制。这种存储方式就是链
1.（3）数据结构之链表的创建和遍历（有图有注释）
爱打羽毛球的程序员
07-23 3796
数据结构之链表的创建和遍历（有图有注释）快速看懂创建和遍历过程
C语言单循环链表的表示与实现实例详解
09-04
在数据结构中，链表是一种基础且重要的数据结构，而单循环链表是链表的一种特殊形式。本文将深入探讨C语言中如何表示和实现单循环链表。 单循环链表的特点在于它的最后一个节点指向了链表的第一个节点，形成一个...
单循环链表
01-02
### 单循环链表知识点详解 #### 一、单循环链表的概念与特点 单循环链表是一种特殊的线性表存储结构，它基于链式存储方式实现。在单循环链表中，所有节点通过指针链接在一起形成一个环形结构，即最后一个节点的指针...
C语言中双向链表和双向循环链表详解
08-30
C语言中双向链表和双向循环链表详解 本文主要介绍了C语言中双向链表和双向循环链表的实现与操作，包括双向链表和双向循环链表的定义、初始化、插入操作、删除操作等。 一、双向链表和双向循环链表的定义 在C语言...
python算法题 链表反转详解
01-20
实现链表反转有两种方式，一种是循环迭代，另外一种方式是递归。 第一种方式：循坏迭代 循坏迭代算法需要三个临时变量：pre、head、next，临界条件是链表为None或者链表就只有一个节点。 # encoding: utf-8 ...
[数据结构]链表之循环链表
beenles的博客
07-17 2240
需要注意的是，在循环链表中，插入和删除操作需要额外考虑最后一个节点的next指针和第一个节点的prev指针的修改。总之，循环链表是一种特殊的链表结构，在实现各种操作时需要注意其连续性和有序性，并针对特殊情况进行相应的处理。需要注意的是，在进行各种操作时，需要保证循环链表的连续性和有序性，以避免数据不一致等问题的发生。需要注意的是，在进行各种操作时，需要保证循环链表的连续性和有序性，即每个节点的next指针都指向下一个节点，并且最后一个节点的next指针指向头节点。但是，其实现简单，无需处理哈希冲突等问题。
循环链表的创建、遍历
热门推荐
Sun.ME的博客
02-19 1万+
循环链表 在单链表中遍历链表时，判断链表终端结点的next指针为空（node-&gt;next=NULL)，则表示当前链表遍历完成。 循环链表中，将单链表中的终端结点的指针端由空指针改为指向头结点，就使整个单链表形成一个环，使得链表的头尾相接，这种链表称之为单循环链表，简称为循环链表++。 循环链表和单链表的主要差异就在于循环的判断条件上，单链表判断循环结束为：node-&gt;next==...
链表
随风
05-22 646
链表： 单向链表： 内存结构示意图： 链表是以节点的方式来存储，也叫链式存储。 每个节点包括data域，next域，next域指向下一个节点。 链表的各个节点之间不一定是连续存储。 链表也分带头节点的链表和不带头节点的链表，根据实际需求来确定。 创建单向链表中增删改查的逻辑思路： 无序单向链表： 无序是指添加数据时，直接添加到链表的尾部。 实现思路：这里以英雄为节点，每个节点存储着英雄的属性。 每个节点包含4个属性，分别是id，name、nickName、next head头节点，
数据结构学习——循环链表的使用
weixin_63586719的博客
07-29 554
循环链表是一种特殊类型的链表，其中链表中的最后一个节点指向链表中的第一个节点，形成循环的结构。与普通链表相比，循环链表可以在链表中的任何位置进行遍历，并且可以方便地实现循环操作。在循环链表中，每个节点通常包含一个数据元素和一个指向下一个节点的指针。链表中的最后一个节点的指针指向第一个节点，形成闭环。
leetcode：环形链表（详解）
weixin_73142957的博客
05-06 1254
前言：内容包括-题目，代码实现，大致思路，代码解读，拓展问题
【算法】环形链表 - 遍历/双指针
最新发布
Counter-Strike大牛
04-07 411
声明一个快指针和一个慢指针，快指针每次移动两步，慢指针移动一步，如果两指针相等则说明有环。声明一个Set，遍历链表放入Set，如果放入失败，说明有环。给定一个链表，判断链表中是否有环，并返回结果。
循环链表遍历的猫腻
博客
03-08 2802
循环链表 循环链表的结构和单链表结构一样，只是单链表的尾结点的next指针指向null，循环链表的尾结点的next指针指向头节点，仅此而已。 图示： 循环链表的其它操作同单链表，但对于遍历循环链表就有一些小技巧了。 循环链表的遍历 第一种： public static void printList(Node head){ Node cur = head; while(cur....
遍历链表
qq_43318548的博客
04-03 4556
对某一数据结构中所有元素按照某种次序注意访问，称为对该数据结构的“遍历”。 案例 分析 输出链表中每一个结点值的函数原型设计为： void print(Node *head); 其中，形式参数head表示获得要输出链表的头指针。 在实现这个函数式，需要黄色至一个指向当前节点的指针P，期初至就是链表的头指针head。当p不不为空（即P指向一个实际存在的结点）时，输出数据元素值p->data，然...
C++双向循环链表详解与模板实现教程
本课程设计详细介绍了如何在C++中实现双向循环链表，并利用模板技术进行编码。首先，我们从基本概念开始，双向循环链表（doubly circular list）是一种特殊的链表结构，它允许元素在链表中双向移动，包括头节点和尾...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值