数据结构（3）—双向链表、循环链表

最新推荐文章于 2025-12-02 19:18:07 发布
原创 最新推荐文章于 2025-12-02 19:18:07 发布 · 954 阅读 · 11 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #链表

一、双向链表

1.定义

typedef int datatype;

typedef struct node
{
        datatype data;                 //存放数据空间
        struct node *ppre;           //存放前一个节点地址
        struct node *pnext;         //存放下一个节点地址
}linknode；

2.创建

申请节点空间，对pnext和ppre赋值为NULL，返回空白节点地址

linknode *create_empty_linklist(void)
{
        linknode *ptmpnode = NULL;
        ptmpnode = malloc(sizeof(linknode));
        if (NULL == ptmpnode)
        {
                perror("fail to malloc");
                return NULL;
        }
        ptmpnode->ppre = NULL;
        ptmpnode->pnext = NULL;
        return ptmpnode;
}

3.头插法

①申请节点

②存放数据

③pnext赋值为phead->pnext

④ppre赋值为phead的地址

⑤phead->pnext赋值为新申请节点地址

⑥如果有后一个节点，需要让后一个节点的ppre指向该节点

int insert_head_linklist(linknode *phead, datatype tmpdata)
{
        linknode *ptmpnode = NULL；

        ptmpnode = malloc(sizeof(linknode));
        if (NULL == ptmpnode)
        {
                perror("fail to malloc");
                return -1;
        }
        ptmpnode->data = tmpdata;
        ptmpnode->pnext = phead->pnext;
        ptmpnode->ppre = phead;
        phead->pnext = ptmpnode;
        if (ptmpnode->pnext != NULL)
        {
                ptmpnode->pnext->ppre = ptmpnode;
        }
        return 0;
}

4.遍历

 具体查看上次单向链表遍历

int show_linklist(linknode *phead)
{
        linknode *ptmpnode = NULL;
        ptmpnode = phead->pnext;
        while (ptmpnode != NULL)
        {
                printf("%d ", ptmpnode->data);
                ptmpnode = ptmpnode->pnext;
        }
        printf("\n");
        return 0;
}

5、查找

具体查看上次单向链表查找

 linknode *find_linklist(linknode *phead, datatype tmpdata)
{
        linknode *ptmpnode = NULL;
        ptmpnode = phead->pnex；

        while (ptmpnode != NULL)
        {
                if (ptmpnode->data == tmpdata)
                {
                        return ptmpnode;
                }
        ptmpnode = ptmpnode->pnext;
        }
        return NULL;
}

6. 修改

具体查看上次单向链表修改

int update_linklist(linknode *phead, datatype olddata, datatype newdata)
{
        linknode *ptmpnode = NULL;
        ptmpnode = phead->pnext;
        while (ptmpnode != NULL)
        {
                if (ptmpnode->data == olddata)
                {
                        ptmpnode->data = newdata;
                }
        ptmpnode = ptmpnode->pnext;
        }
        return 0;
}

7.删除

①找到要删除的节点

②让删除节点的前一个节点的pnext指向要删除节点的后一个节点

③让删除节点的后一个节点的ppre指向要删除节点的前一个节点

④将要删除的节点释放掉

int delete_linklist(linknode *phead, datatype tmpdata)
{
        linknode *ptmpnode = NULL;
        linknode *pfreenode = NULL;         //需要定义两个变量，因为如果只有一个变量被释放                                                                   后，无法继续遍历
        ptmpnode = phead->pnext;
        while (ptmpnode != NULL)
        {
                if (ptmpnode->data == tmpdata)
                {
                        ptmpnode->ppre->pnext = ptmpnode->pnext;
                        if (ptmpnode->pnext != NULL)           //判断要删除的节点是否为最后一个
                        {
                                ptmpnode->pnext->ppre = ptmpnode->ppre;
                        }
                pfreenode = ptmpnode;
                ptmpnode = ptmpnode->pnext;
                free(pfreenode);
                }
                else           //如果不加else会向后推进两个节点，导致无法全部遍历
                {
                        ptmpnode = ptmpnode->pnext;
                }
        }
        return 0;
}

8. 销毁

具体查看上次单向链表销毁

int destroy_linklist(linknode **pphead)
{
        linknode *ptmpnode = NULL;
        linknode *pfreenode = NULL;
        ptmpnode = *pphead;
        pfreenode = ptmpnode;
        while (ptmpnode != NULL)
        {
                ptmpnode = ptmpnode->pnext;
                free(pfreenode);
                pfreenode = ptmpnode;
        }
        *pphead = NULL;
        return 0;
}

9.尾插法

①申请节点

②将节点的pnext赋值为NULL

③找到链表最后一个节点

④将节点的ppre赋值为最后一个节点地址

⑤将最后一个节点的pnext赋值为新申请节点

int insert_tail_linklist(linknode *phead, datatype tmpdata)
{
        linknode *ptmpnode = NULL;
        linknode *plastnode = NULL;
        ptmpnode = malloc(sizeof(linknode));
        if (NULL == ptmpnode)
        {
                perror("fail to malloc");
                return -1;
        }
        plastnode = phead;
        while (plastnode->pnext != NULL)
        {
                plastnode = plastnode->pnext;
        }
        ptmpnode->data = tmpdata;
        ptmpnode->pnext = NULL;
        ptmpnode->ppre = plastnode;
        plastnode->pnext = ptmpnode;
        return 0;
}

二、循环列表

1. 头结点的ppre指向链表最后一个节点，最后节点的pnext指向第一个节点，可以通过头节点或尾节点定位到头节点和尾节点

2.定义

typedef int datatype;

typedef struct node
{
        datatype data;                 //存放数据空间
        struct node *ppre;           //存放前一个节点地址
        struct node *pnext;         //存放下一个节点地址
}linknode；

3.创建

申请节点，pnext和ppre都指向自己

linknode *create_empty_linklist(void)
{
        linknode *ptmpnode = NULL;
        ptmpnode = malloc(sizeof(linknode));
        if (NULL == ptmpnode)
        {
                perror("fail to malloc");
                return NULL;
        }
        ptmpnode->pnext = ptmpnode->ppre = ptmpnode;
        return ptmpnode;
}

4.头插法

①申请节点空间

②存放数据

③将pnext指向空白节点的pnext

④将ppre指向空白节点

⑤将空白节点的pnext指向新申请节点

⑥将后续节点的ppre指向新申请节点

int insert_head_linklist(linknode *phead, datatype tmpdata)
{
        linknode *ptmpnode = NULL;
        ptmpnode = malloc(sizeof(linknode));
        if (NULL == ptmpnode)
        {
                perror("fail to malloc");
                return -1;

        }
        ptmpnode->data = tmpdata;
        ptmpnode->pnext = phead->pnext;
        ptmpnode->ppre = phead;
        ptmpnode->pnext->ppre = ptmpnode;
        ptmpnode->ppre->pnext = ptmpnode;
        return 0;
}

 5.尾插法

①申请节点空间

②将数据存放到节点中

③将pnext赋值为空白节点

④将ppre赋值为之前的最后一个节点地址

⑤将之前最后一个节点的pnext指向新申请节点

⑥将空白节点的ppre指向新申请节点

int insert_tail_linklist(linknode *phead, datatype tmpdata)
{
        linknode *ptmpnode = NULL;
        ptmpnode = malloc(sizeof(linknode));
        if (NULL == ptmpnode)
        {
                perror("fail to malloc");
                return -1;
        }
        ptmpnode->data = tmpdata;
        ptmpnode->pnext = phead;
        ptmpnode->ppre = phead->ppre;
        ptmpnode->pnext->ppre = ptmpnode;
        ptmpnode->ppre->pnext = ptmpnode;
        return 0;
}

6.遍历

其他与双向链表无差别，唯一的差别是循环链表最终循环条件由 != NULL修改为 != phead

int show_linklist(linknode *phead)
{
        linknode *ptmpnode = NULL;
        ptmpnode = phead->pnext;
        while (ptmpnode != phead)
        {
                printf("%d ", ptmpnode->data);
                ptmpnode = ptmpnode->pnext;
        }
        printf("\n");
        return 0;
}

7.查找

具体与双向链表的查找方法一致

 linknode *find_linklist(linknode *phead, datatype tmpdata)
{
        linknode *ptmpnode = NULL;
        ptmpnode = phead->pnext;
        while (ptmpnode != phead)
        {
                if (ptmpnode->data == tmpdata)
                {
                        return ptmpnode;
                }
                ptmpnode = ptmpnode->pnext;
        }
        return NULL;
}

8. 修改

具体与双向链表的修改方法一致

int update_linklist(linknode *phead, datatype olddata, datatype newdata)
{
        linknode *ptmpnode = NULL;
        ptmpnode = phead->pnext;
        while (ptmpnode != phead)
        {
                if (ptmpnode->data == olddata)
                {
                        ptmpnode->data = newdata;
                }
        ptmpnode = ptmpnode->pnext;
        }
        return 0;
}

9.删除

具体与双向链表的删除方法一致，但是无需判断是否有pnext，因为循环链表永远有pnext

 int delete_linklist(linknode *phead, datatype tmpdata)
{
        linknode *ptmpnode = NULL;
        linknode *pfreenode = NULL;
        ptmpnode = phead->pnext;
        while (ptmpnode != phead)
        {
                if (ptmpnode->data == tmpdata)
                {
                        ptmpnode->ppre->pnext = ptmpnode->pnext;
                        ptmpnode->pnext->ppre = ptmpnode->ppre;
                        pfreenode = ptmpnode;
                        ptmpnode = ptmpnode->pnext;
                        free(pfreenode);
                }
                else
                {
                        ptmpnode = ptmpnode->pnext;
                }

        }
        return 0;
}

10.销毁

 具体与双向链表的销毁方法一致，但是需要从第一个非空节点开始销毁，因为判断条件是！=*pphead，如果销毁会导致无法进入循环；循环结束后要单独释放*pphead

int destroy_linklist(linknode **pphead)
{
        linknode *ptmpnode = NULL;
        linknode *pfreenode = NULL;
        ptmpnode = (*pphead)->pnext;
        pfreenode = ptmpnode;
        while (ptmpnode != *pphead)
        {
                ptmpnode = ptmpnode->pnext;
                free(pfreenode);
                pfreenode = ptmpnode;
        }
        free(*pphead);
        *pphead = NULL;
        return 0;
}

三、 内核链表

1.是Linux内核中所使用到的一种链表结构，使用同一种结构可以存储不同类型的链表；普通链表是链表节点中包含数据，而内核链表是数据中包含链表节点。

2.结构描述

 

创建：创建空白节点即可（只需给ppre和pnext初始化）

插入：申请节点，并按照之前学习的循环链表插入即可（插入的链表节点首地址即数据节点首地
址）

访问节点：通过遍历找到每个节点的首地址，强制类型转换即可获得对应数据空间首地

Childecool
关注
数据结构——双向循环链表
qq_67611811的博客
08-28 2509
双向循环链表，在原单链表的基础上多了一个指向上一个结点的前驱指针prev，这样前后结点就不仅仅有了单向的从头至尾的指向顺序，也可以从后指向前，从末结点指向头结点。双向带头循环链表结构} DGR;加入前驱指针后，不管是对于链表数据的尾插尾删，或是头插头删，其时间复杂度都为O(1)，大大简化了链表遍历过程，而可以直接在链表首尾增减数据，因为一个链表的末节点可由头结点的前驱指针直接访问而不需要遍历至尾。为了简化文本描述，本章双向循环带头链表均简称为双向链表。...
进阶数据结构——双向循环链表
ycs66的博客
02-01 1063
这一期我们学习双向循环链表。双向循环链表不同于单链表，双向循环链表是一种特殊的数据结构，它结合了双向链表和循环链表的特点。双向循环链表中的每个节点都包含三个部分：数据域（存储数据）、前驱指针（指向前一个节点）和后继指针（指向下一个节点）。此外，链表的头节点和尾节点通过指针相互连接，形成一个闭环。这种结构使得链表可以从任意一个节点开始遍历整个链表。综上所述，双向循环链表是一种功能强大且灵活的数据结构，适用于需要频繁访问链表前后节点的场景。
数据结构——双向链表
xiaoxin_________的博客
02-03 1018
（存储元素）、（prev）和（next）。与单向链表不同，双向链表的节点不仅可以通过下一个节点（next）进行访问，还可以通过前一个节点（prev）进行访问，因此它支持从两个方向进行遍历。这种结构使得在任意节点的插入、删除以及遍历操作都非常高效。希望这个简要的图示和说明可以帮助你理解双向链表的基本概念！
数据结构双向链表和循环链表
2303_80883523的博客
09-29 1119
循环链表就是首尾相接的的链表，就是尾节点的指针域指向头节点使整个链表形成一个循环，这就弥补了以前单链表无法在后面某个节点找到前面的节点，可以从任意一个节点找到目标节点，但是现在我们就不能像以前那样停止循环时的判断条件是否为NULL了，而是判断是否指向头指针。双向链表的空表里面两个指针装的都是空指针。即使我们有了双向链表，但是当我们想要在尾节点找到头节点附近某个节点仍然不够快捷，所以就引进了循环双向链表的概念，不过判断条件这些就需要改变：判断结束条件从NULL变为链表名L。
数据结构（双向链表）
2301_80475151的博客
09-19 1340
本文介绍了带头双向循环链表的实现
数据结构-循环链表和双向链表
pyc68的博客
06-29 3745
本篇文章介绍数据结构中的循环链表和双向链表
【数据结构】双向链表、单向循环链表、双向循环链表、栈、链栈
bananapai的博客
11-25 2838
双向链表的操作，单向循环链表，双向循环链表的实现。何为栈，栈的存储方式是什么，什么是链栈。
数据结构——双向链表、循环链表
龍弟-idea的博客
11-29 3428
目录 双链表的实现 java中LinkedList实现 链表的复杂度分析 循环链表 双向链表，它由多个结点组成，每个结点都由一个数据域和两个指针域组成，数据域用来存储数据，其中一个指针域用来指向其后继结点，另一个指针域用来指向前驱结点。链表的头结点的数据域不存储数据，指向前驱结点的指针域值为null...
数据结构：双向链表（带头循环）
Yikefore的博客
05-11 1227
带头双向循环链表实现的详细介绍，带图解和完整的代码。
【数据结构】单链表 双向链表
yj20040627的博客
07-11 3955
单链表 双向链表实现
Gemini永久会员 归并排序（Merge Sort） 基于分治思想（Divide and Conquer）的高效排序算法
m0_37843156的博客
11-29 534
归并排序（Merge Sort）是一种基于分治思想（Divide and Conquer）的高效排序算法，其核心步骤包括。通过分治和合并的巧妙设计，归并排序在保证稳定性的同时实现了高效排序，是理解算法分治思想的经典案例。
数据结构：队列
最新发布
Yolo_TvT的博客
12-02 291
队列简介及代码实现
数据结构：集合
闲余知道
12-02 496
数据结构：集合
算法基础篇：（二十一）数据结构之单调栈：从原理到实战，玩转高效解题
2301_79248256的博客
11-29 1548
本文深入解析了单调栈这一高效数据结构。首先介绍了单调栈的基本概念，即在普通栈的基础上增加元素单调性约束，可分为递增栈和递减栈。接着详细讲解了四种核心应用场景：寻找左右侧最近更大/更小元素，并提供了对应的C++代码实现。通过洛谷P5788等模板题和发射站、柱状图最大矩形等实战案例，展示了单调栈如何将O(n²)问题优化为O(n)解法。最后总结了单调性选择、遍历方向等核心技巧，并给出避免数据溢出、优化IO等实用建议。掌握单调栈能有效解决"找最近最值"类问题，是算法竞赛和面试中的重要工具。
数据结构基本知识
2501_90980137的博客
11-30 606
• 队列：“先进先出”（FIFO），允许在队尾入队、队首出队，支持enqueue（入队）、dequeue（出队），基础队列O(1)操作，优先级队列（按优先级排序）O(logn)操作，常用于任务调度、广度优先搜索（BFS）。• 栈：“先进后出”（LIFO），仅允许在栈顶操作，支持push（入栈）、pop（出栈）、peek（查看栈顶），时间复杂度均为O(1)，常用于递归、表达式求值、括号匹配。• 表示方法：邻接矩阵（二维数组，适合稠密图）、邻接表（链表数组，适合稀疏图）。
【数据结构】二叉树OJ
Z2382430464的博客
12-02 632
本题代码与100相同的树非常相似，只是在递归调用时参数由p的左子树和q的左子树、p的右子树和q的右子树比较变为p的左子树和q的右子树、q的右子树和q的左子树比较。将二叉树分为根节点和左右子树，递归判断二叉树中所有子树的结点是否相等，如果不同则返回false，判断完全部结点说明全部结点的值都相等，返回true。判断子树的根节点和另一颗树的结点是否相同，如果相同则以相同的结点为根节点判断两棵子树是否相同。一棵树是否对称与根节点无关，所以可以忽略根节点，判断根节点的左右子树是否是对称的即可。
数据结构：算法复杂度
Yolo_TvT的博客
11-30 473
本文简介了算法复杂度（时间复杂度和空间复杂度），并介绍了如何用大O记法来描述算法复杂度
数据结构1111
2501_91992196的博客
11-29 442
他刚刚说的，我不需要知道这个方法里面的细节我只知道它能实现这个功能，让我莫名想到了网络中的东西，那个什么鬼上层不需要知道下层的具体原理什么的。正在做的事情就是跑在内存上的，这话似曾相识，好像计算机网络的课中讲过正在运行的程序什么的。比如说数组相同数据类型放在一起，这就是一个结构，多个数据元素组织在一起。我希望能更直观的展现这个情况（每个人的信息），用什么方式最好呢？C语言中没有这幅串的数据类型，Java中好像有这样的数据类型。返回值返回到调用的地方，就用相应的类型接收。不同的需求，不同的形式。
数据结构 带头节点的双向循环链表
似流水般平静而坚定。
12-01 278
本文实现了一个带头节点的双向循环链表，包含初始化、插入、删除等基本操作。链表节点包含数据域和前后指针，链表结构体维护头节点和当前大小。主要功能包括：1）初始化链表；2）在指定节点前插入元素；3）打印链表；4）删除指定节点；5）头删/尾删；6）头插/尾插。每个操作都处理了指针调整和内存管理，并维护链表大小。代码使用断言检查参数有效性，确保操作安全。这种实现方式适用于需要频繁在头部/尾部操作的场景，循环特性简化了边界条件处理。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值