循环链表C语言实现（非伪代码）

于 2024-10-01 15:12:30 发布
阅读量557 收藏 12
点赞数 24
文章标签： 链表 c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79365218/article/details/142670758
版权

循环链表建议自己一定要下去实现一遍，你会发现和普通的单链表还是有很大区别的，尤其是遍历的时候循环的条件！！

一、创建一个链表

// 创建一个链表
void Creat_LinkedList(LinkedList* list) 
{
    list->head = NULL;
    list->len = 0;
}

二、销毁一个循环链表

2.1、核心代码实现：

注意：

1、 因为在循环链表中，我们不能移动头指针的位置，所以相较于普通链表的销毁，我们还多需要一个结点来进行缓存的操作

2、使用do--while是因为current的初始值就是list->head，所以需要使用do--while先跳过一轮，防止直接退出

// 销毁一个链表
void Destroy_LinkList(LinkedList* list) 
{
    //因为在循环链表中，我们不能移动头指针的位置，
    //所以相较于普通链表的销毁，我们还多需要一个结点来进行缓存的操作

    if (list->head == NULL) return; // 空链表

    ListNode* current = list->head; //定义一个迭代器指向头节点
    ListNode* temp;  //用来暂存结点 来释放结点

    //使用do--while是因为current的初始值就是list->head
    //所以需要使用do--while先跳过一轮，防止直接退出
    do {
        temp = current; // 定义一个值指向
        current = current->next; // 移动到下一个节点
        free(temp); // 释放当前节点
    } while (current != list->head); // 检查是否回到头节点

    list->head = NULL;
    list->len = 0;
}

2.2、代码图解：

1、用一个temp指向current

2、current往下移一位

3、释放free

三、插入元素

3.1、核心代码实现：

// 在链表中插入一个元素，在第i个位置插入value值
void Insert_LinkList(LinkedList* list, int i, int value) 
{
    if (i < 0 || i > list->len) //越界
    {
        printf("插入失败\n");
        return;
    }

    ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
    newNode->data = value;

    if (list->len == 0) // 如果链表为空
    { 
        newNode->next = newNode; // 指向自身
        list->head = newNode; // 新节点为头节点
    }
    else if (i == 0) // 插入到头部，头插法
    { 
        ListNode* tail = list->head;
        while (tail->next != list->head) // 找到尾节点
        { 
            tail = tail->next;
        }
        newNode->next = list->head; // 新节点指向头
        tail->next = newNode; // 尾节点指向新节点
        list->head = newNode; // 更新头节点
    }
    else //尾插法
    {
        ListNode* current = list->head;

        for (int j = 0; j < i - 1; j++) 
        {
            current = current->next;
        }
        newNode->next = current->next;
        current->next = newNode;
    }
    list->len++;
}

3.2、代码图解

3.2.1：当链表为空时

下一个结点指向自身

头节点指向当前结点

 3.2.2、当链表不为空，且需要插入元素到头部时

1、定义一个tail指针，指向头节点

2、遍历到尾结点

3、同普通链表一致，修改指针指向即可

 3.2.3：当链表不为空，且需要插入元素到链表中时

1、定义一个迭代器cur指向头节点，

2、遍历到第i-1个下标

3、改变指针指向

 四、删除元素

4.1、核心代码实现

// 删除节点，把第i个元素删除
void Delete_LinkList(LinkedList* list, int i) 
{
    if (i < 0 || i >= list->len) //下标越界
    {
        printf("删除失败\n");
        return;
    }
    ListNode* toDelete = list->head;

    if (i == 0) // 删除头节点
    { 
        ListNode* tail = list->head;    //定义一个迭代器指向 头节点
        while (tail->next != list->head) //移动tail到 尾节点
        {
            tail = tail->next;
        }
        if (list->len == 1) // 只有一个节点 
        { 
            free(list->head);
            list->head = NULL;
        }
        else //不只有一个头节点
        {
            tail->next = toDelete->next; // 更新尾节点指向
            list->head = toDelete->next; // 更新头节点
            free(toDelete);
        }
    }
    else //删除的结点不是头结点
    {
        ListNode* current = list->head; 
  
        for (int j = 0; j < i - 1; j++) //找到要删除的结点的前一个结点
        {
            current = current->next;
        }
        toDelete = current->next;   //把toDelete指向cur->next
        current->next = toDelete->next; //把cur->next指向toDelete的next
        free(toDelete);
    }
    list->len--;
}

 4.2、代码图解：

4.2.1、删除头节点，且只有一个元素

释放头节点，置空即可。

4.2.2、删除头节点，但不只有一个元素

0、定义一个toDelete结点，指向头节点，表示要删除头节点，用来最后的释放

1、定义一个迭代器tail指向头节点

2、把tail移动到尾结点

3、更新尾结点的指向

4、更新头节点

5、删除要删除的结点

4.2.3、删除的结点不是头节点：

0、定义一个toDelete，指向头结点

1、定义一个迭代器current，指向头节点

2、把current移动到要删除结点的前一个结点

3、把toDelete指向current的下一个结点，即指向要删除的结点。

4、把cur->next指向toDelete的next.

5、释放要删除的结点toDelete

 五、通过元素来查找链表节点

5.1核心代码实现： 

// 通过元素来查找链表节点
ListNode* Find_element_Linked(LinkedList* list, int value) 
{
    if (list->head == NULL) return NULL; // 空链表
    ListNode* current = list->head;

    do 
    {
        if (current->data == value) //简单！！和单链表一致
        {
            return current;
        }
        current = current->next;
    } while (current != list->head);

    return NULL; // 没有找到
}

5.2、代码图解：

 六、通过下标来查找链表节点：

// 通过下标来寻找链表的节点，寻找第i个元素
ListNode* Find_Index_Linked(LinkedList* list, int i) 
{
    if (i < 0 || i >= list->len)
    {
        printf("寻找错误\n");
        return NULL;
    }

    ListNode* current = list->head;

    for (int j = 0; j < i; j++) //因为链表的下标默认从0开始 
    {
        current = current->next;
    }
    return current;
}

七、更新链表元素

// 更新链表的元素
void Update_LInked(LinkedList* list, int i, int value) 
{
    ListNode* temp = Find_Index_Linked(list, i);    //调用寻找元素下标的函数，直接获取要更新的元素的结点指针
    
    if (temp) 
    {
        temp->data = value;
    }
    //可以不用加Ddeque语句，因为Find_Index_Linked程序中已经有了
}

八、遍历打印链表的元素

//打印链表的元素
void Print_Linked(LinkedList* list) 
{
    if (list->head == NULL) 
    {
        printf("链表为空\n");
        return;
    }

    ListNode* current = list->head;

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

    printf("(回到头节点)\n");
}

总结：完整代码的实现：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>

typedef struct ListNode { // 创建循环链表单独节点
    int data; // 数值域
    struct ListNode* next; // 下一个节点的指针域
} ListNode;

typedef struct LinkedList { // 完整的链表
    ListNode* head; // 头节点
    int len; // 长度
} LinkedList;


// 创建一个链表
void Creat_LinkedList(LinkedList* list) 
{
    list->head = NULL;
    list->len = 0;
}


// 销毁一个链表
void Destroy_LinkList(LinkedList* list) 
{
    //因为在循环链表中，我们不能移动头指针的位置，
    //所以相较于普通链表的销毁，我们还多需要一个结点来进行缓存的操作

    if (list->head == NULL) return; // 空链表

    ListNode* current = list->head; //定义一个迭代器指向头节点
    ListNode* temp;  //用来暂存结点 来释放结点

    //使用do--while是因为current的初始值就是list->head
    //所以需要使用do--while先跳过一轮，防止直接退出
    do {
        temp = current; // 定义一个值指向
        current = current->next; // 移动到下一个节点
        free(temp); // 释放当前节点
    } while (current != list->head); // 检查是否回到头节点

    list->head = NULL;
    list->len = 0;
}


// 在链表中插入一个元素，在第i个位置插入value值
void Insert_LinkList(LinkedList* list, int i, int value) 
{
    if (i < 0 || i > list->len) //越界
    {
        printf("插入失败\n");
        return;
    }

    ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
    newNode->data = value;

    if (list->len == 0) // 如果链表为空
    { 
        newNode->next = newNode; // 指向自身
        list->head = newNode; // 新节点为头节点
    }
    else if (i == 0) // 插入到头部，头插法
    { 
        ListNode* tail = list->head;
        while (tail->next != list->head) // 找到尾节点
        { 
            tail = tail->next;
        }
        newNode->next = list->head; // 新节点指向头
        tail->next = newNode; // 尾节点指向新节点
        list->head = newNode; // 更新头节点
    }
    else //尾插法
    {
        ListNode* current = list->head;

        for (int j = 0; j < i - 1; j++) 
        {
            current = current->next;
        }
        newNode->next = current->next;
        current->next = newNode;
    }
    list->len++;
}

// 删除节点，把第i个元素删除
void Delete_LinkList(LinkedList* list, int i) 
{
    if (i < 0 || i >= list->len) //下标越界
    {
        printf("删除失败\n");
        return;
    }
    ListNode* toDelete = list->head;

    if (i == 0) // 删除头节点
    { 
        ListNode* tail = list->head;    //定义一个迭代器指向 头节点
        while (tail->next != list->head) //移动tail到 尾节点
        {
            tail = tail->next;
        }
        if (list->len == 1) // 只有一个节点 
        { 
            free(list->head);
            list->head = NULL;
        }
        else //不只有一个头节点
        {
            tail->next = toDelete->next; // 更新尾节点指向
            list->head = toDelete->next; // 更新头节点
            free(toDelete);
        }
    }
    else //删除的结点不是头结点
    {
        ListNode* current = list->head; 
  
        for (int j = 0; j < i - 1; j++) //找到要删除的结点的前一个结点
        {
            current = current->next;
        }
        toDelete = current->next;   //把toDelete指向cur->next
        current->next = toDelete->next; //把cur->next指向toDelete的next
        free(toDelete);
    }
    list->len--;
}

// 通过元素来查找链表节点
ListNode* Find_element_Linked(LinkedList* list, int value) 
{
    if (list->head == NULL) return NULL; // 空链表
    ListNode* current = list->head;

    do 
    {
        if (current->data == value) //简单！！和单链表一致
        {
            return current;
        }
        current = current->next;
    } while (current != list->head);

    return NULL; // 没有找到
}


// 通过下标来寻找链表的节点，寻找第i个元素
ListNode* Find_Index_Linked(LinkedList* list, int i) 
{
    if (i < 0 || i >= list->len)
    {
        printf("寻找错误\n");
        return NULL;
    }

    ListNode* current = list->head;

    for (int j = 0; j < i; j++) //因为链表的下标默认从0开始 
    {
        current = current->next;
    }
    return current;
}

// 更新链表的元素
void Update_LInked(LinkedList* list, int i, int value) 
{
    ListNode* temp = Find_Index_Linked(list, i);    //调用寻找元素下标的函数，直接获取要更新的元素的结点指针
    
    if (temp) 
    {
        temp->data = value;
    }
    //可以不用加Ddeque语句，因为Find_Index_Linked程序中已经有了
}

//打印链表的元素
void Print_Linked(LinkedList* list) 
{
    if (list->head == NULL) 
    {
        printf("链表为空\n");
        return;
    }

    ListNode* current = list->head;

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

    printf("(回到头节点)\n");
}

int main() 
{
    LinkedList list; //定义一个链表
    Creat_LinkedList(&list);    //创建链表

    Insert_LinkList(&list, 0, 10);
    Insert_LinkList(&list, 1, 20);
    Insert_LinkList(&list, 2, 30);
    Insert_LinkList(&list, 3, 40);

    printf("Original List:\n");
    Print_Linked(&list);

    Delete_LinkList(&list, 2);
    Update_LInked(&list, 1, 100);
    printf("Change1 List:\n");
    Print_Linked(&list);

    ListNode* found = Find_element_Linked(&list, 30); //通过元素寻找元素

    if (!found) 
    {
        printf("此节点不存在\n");
    }

    Destroy_LinkList(&list); // 销毁链表
    system("pause");
    return 0;
}

 纯私人撰写，欢迎大家私信勘误！！

Erik_LinX
关注
链表基本操作伪代码
weixin_47500703的博客
03-13 3065
文章目录链式结构体头插法创建尾插法求表长按值查找按位查找插入删除按值删除(first)按值删除(all)有序表的合并循环链表双向链表静态链表 链式结构体 typedef int ElemType; typedef struct LNode { ElemType data; struct LNode *next; } LNode, *LinkList; //声明变量 LinkList L; 头插法创建 Initial(LinkList &L) { L = (LinkList
将两个链表（可为乱序）合并成一个有序链表（C语言实现）
weixin_50080319的博客
11-07 4054
谭浩强c语言第五版第9章的习题10，本文主题如下： 1.对参考答案代码进行解析和勘误； 2.提出一种更准确的算法，给出代码；
C语言实现链表模板（非伪代码）
2301_79365218的博客
09-27 350
typedef struct ListNode{ //创建链表单独结点int data;//数值域//下一个结点的指针域}ListNode;typedef struct LinkedList { //完整的链表//头结点，也就是一个单独结点int len;//长度。
链表c语言代码 反转函数,单链表反转C语言实现
weixin_42298969的博客
05-21 846
单链表的反转可以使用循环，也可以使用递归的方式1.循环反转单链表循环的方法中，使用pre指向前一个结点，cur指向当前结点，每次把cur->next指向pre即可。 代码：# include # include using namespace std;struct linkNode{int val;linkNode *next;linkNode(int x):val(x),next(NULL...
C语言实现链表的基本操作（超详细注释）
weixin_63069485的博客
03-28 1万+
第一次学数据结构的时候，c语言基础实在太差，在尝试用c语言来实现的时候一直碰壁，数据结构书里的代码是伪代码，使用的时候各种内存访问冲突，各种锟斤拷烫烫烫，各种变量级别不同。于是我又重新学了一遍c语言，并且又看了一本详细阐述c语言指针有关的书，终于明白了，以前为什么出那么多错。之前一直出错的本质就是没有理解指针。学完了以后，现在已经可以成功使用C语言实现数据结构中的算法了。分享一下我的学习成果，希望和我一样的人也能少走弯路。
数据结构回顾——循环链表操作详解及C语言实现
只要思想不滑坡，想法总比问题多。
08-21 1036
循环链表指的是一个链式表以一个环状的形式存在，即是链表头尾节点相连在一起。循环链表从任意节点开始，可以遍历整个链表，遍历灵活性高。
循环队列c语言的实现,循环队列的C语言实现
weixin_39645041的博客
05-24 164
生活中有很多队列的影子，比如打饭排队，买火车票排队问题等，可以说与时间相关的问题，一般都会涉及到队列问题；从生活中，可以抽象出队列的概念，队列就是一个能够实现“先进先出”的存储结构。队列分为链式队列和静态队列；静态队列一般用数组来实现，但此时的队列必须是循环队列，否则会造成巨大的内存浪费；链式队列是用链表来实现队列的。这里讲的是循环队列，首先我们必须明白下面几个问题一、循环队列的基础知识1.循环队...
单向链表之逆序（C语言实现）
热门推荐
peng_fp的博客
03-20 1万+
链表的创建查看 逆序思想： 1、链表为空时：不需要逆序； 2、链表只有一个节点时：不需要逆序； 3、链表的节点为两个以及两个以上时：需要逆序 结构体节点： typedef struct student { int num; //学号 int score; //分数 char name[20]; struct student
C语言实现链表、堆栈和队列
微小冷的学习笔记
12-13 2665
通过C语言实现单向链表、有序链表、循环链表、数组堆栈、链式堆栈以及对了，并且给出了一种堆栈的面向对象形式。
链表的C语言实现之单链表的查找运算
08-03
在上述代码中，`creat`函数用于创建一个包含N个节点的单链表，`search`函数接受链表的头指针和要查找的姓名，然后遍历链表执行查找操作。`main`函数演示了如何使用这些功能，包括创建链表、输入要查找的姓名以及调用...
C语言循环链表做的一个电话本
12-19
本文将深入探讨如何使用C语言实现一个基于循环链表的电话本程序。 首先，我们来理解循环链表的基本概念。循环链表与普通链表的主要区别在于其最后一个节点的指针指向了链表的第一个节点，形成了一个闭合的环。这种...
链表的c语言实现.chm
12-25
1.为什么用动态内存分配 2.单链表的建立 3.单链表的基本运算 4.循环链表 5.双向链表 6.双向链表的基本运算 7.综合实例
ccfcsp202009-1 称检测点查询
m0_74834821的博客
09-26 476
int n,X,Y;i<n;i++){i<n;i++){int q;int t=3;i<n;i++){min=d[i];q=i;d[q]=10000;return 0;
（JAVA）队列 和 符号表 两种数据结构的实现
ZunXin_2580的博客
09-27 606
如果想要清晰的认识队列或者符号表是怎样的结构，那么就来看看这篇文章吧！！
[数据结构] 二叉树题目(一)
nmbg11的博客
09-27 464
leetcode有关二叉树的相关题目. 翻转二叉树. 相同的树. 对称二叉树.
数据结构（Map、Set、搜索树）
wuweixiaoyue的博客
09-27 799
概念优势：查找元素时可以直接砍去一半的值，达到 log(N)示例：此时如果要找4，因为4比6小，所以要去6的左边找，此时因为4比3大，所以要去3的右树找，最终找到了如果找到了就返回，如果直到全部找完遇到null了也没找到，说明该搜索树下根本就没有该元素有序问题：二叉搜索树的中序遍历是有序的概念：Map和Set是专门用来进行搜索的容器或数据结构Set是纯key模型，Map是 Key-Value 模型Set最大的功能就是对集合中的元素进行去重接口实例化。
数据结构和算法基础（一）
最新发布
叶子叶来
09-30 412
趁空闲时间刷一遍极客时间上王争的《数据结构与算法之美》课程，个人觉得写的很好，每章节由浅入深且从基础到引入设计类问题，如果写过很多代码想要进行架构设计转型时再回头看这些基础知识还蛮有趣的，以下纪录下随着课程走的部分实现代码和思考； 内容主要是笔记和代码，注：手写一遍代码是有必要的；
python-ds：Python 中的数据结构库（适用于面试的数据结构和算法合集）
技术无疆
09-27 1904
python-ds 是一个开源的 Python 数据结构库，旨在提供多种高级数据结构的实现，如链表、树、图等。这些数据结构可用于解决各种计算问题，增强 Python 在数据处理和算法开发方面的能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值