数据结构3-双向链表、循环链表

于 2025-08-05 19:37:05 发布
阅读量734 收藏 17
点赞数 27
CC 4.0 BY-SA版权
分类专栏： 嵌入式学习 文章标签： 数据结构 链表 双向链表 循环链表 内核链表 双向链表的删除 链表节点空间的释放
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DebugKitty/article/details/149941280

摘要：本文详细介绍了三种链表结构的实现：双向链表、循环链表和内核链表。主要内容包括：1. 双向链表的节点定义、创建、头插/尾插法、遍历、查找、修改、删除和销毁操作的C语言实现；2. 循环链表的特殊处理（首尾相连）及各操作的实现差异；3. 内核链表的特点（节点嵌入数据结构）及其与传统链表的区别。通过代码示例和操作步骤说明，系统讲解了每种链表的基本操作原理和实现要点，包括指针处理、内存管理等关键技术细节。

一、双向链表

（一）链表节点的定义

1、定义的代码实现：

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

（二）空白链表的创建

1、步骤：

  1. 申请节点空间
  2. 对pnext和ppre赋值为NULL
  3. 返回空白节点地址即可

图例

2、代码实现：

/* 创建一个空链表 */

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;
}

（三）链表的头插法

1、步骤：

  1. 申请节点
  2. 存放数据
  3. pnext赋值为phead->pnext
  4. ppre赋值为phead的地址
  5. phead->pnext赋值为新申请节点地址
  6. 如果有后一个节点，需要让后一个节点的ppre指向该节点

2、代码实现：

/* 链表头插法 */
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;

}

3、注意事项：

        与单向链表思想上的不同是：要判断ptmpnode->pnext；后面还有没有节点。

（四）链表尾插法

1、步骤：

  1. 申请节点
  2. 将节点的pnext赋值为NULL
  3. 找到链表最后一个节点
  4. 将节点的ppre赋值为最后一个节点地址
  5. 将最后一个节点的pnext赋值为新申请节

2、代码实现：

/* 链表尾插法 */
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、步骤：与单向链表类似

2、代码实现：

/* 链表的遍历 */
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;
}

（六）链表的查找

1、步骤：与单向链表类似

2、代码实现：

/* 链表的查询 */
linknode *find_linklist(linknode *phead, datatype tmpdata)
{
        linknode *ptmpnode = NULL;
        ptmpnode = phead->pnext;

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


        return NULL;
}

（七）链表的修改

1、步骤：与单向链表的类似

2、代码实现：

/* 链表的修改 */
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;
}

（八）链表的删除

1、步骤：

  1. 找到要删除的节点
  2. 让删除节点的前一个节点的pnext指向要删除节点的后一个节点
  3. 让伤处节点的后一个节点的ppre指向要删除节点的前一个节点
  4. 将要删除的节点释掉

        <细节版>

  1. 定义两个指针ptmpnode、pfreenode，ptmpnode用来遍历寻找要删除的数据
  2. 将ptmpnode->pnext->ppre = ptmpnode->ppre;
  3. 将ptmpnode->ppre->pnext = ptmpnode->pnext;
  4. 令pfreenode = ptmpnode，ptmpnode往前进一步
  5. 释放pfreenode空间

图例

2、代码实现：

/* 链表的删除 */

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
                {
                        ptmpnode = ptmpnode->pnext;
                }
        }
        return 0;
}
 

3、注意事项：

1）设置两个指针的作用：

① 删除链表元素完要释放空间，所以需要定于一个指针（pfreenode后续称为A）指向此时的位置（ptmpnode后续称为B）。

② 若没有A，直接释放掉B之后我们就找不到被删除的下一个节点位置。

③ 所以需要A指向B此时的位置，然后让B往前再走一个节点到达下一个节点。然后释放掉A指向节点的空间。

2）解析释放空间的操作：

       free(pfreenode);   释放的是该指针指向的空间，而不是指针本身。该操作之后此指针就为悬垂指针。pfreenode仍然可以重新指向别的空间。所以为了误用，规范使用最好释放后立即置空。

（九）链表的销毁

1、步骤：与单向链表类似

2、代码实现：

/* 链表的销毁 */
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;
}

二、循环链表

（一）节点定义

1、步骤：与双向链表类似

2、代码实现：

/* 节点存放数据的类型 */
typedef int datatype;


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

（二）链表创建

1、步骤：

  1. 申请节点
  2. pnext和ppre都指向自己

2、代码实现：

/* 创建空链表 */
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;
}

（三）链表头插法

1、步骤：

  1. 申请节点空间
  2. 存放数据
  3. 将pnext指向空白节点的pnext
  4. 将ppre指向空白节点
  5. 将空白节点的pnext指向新申请节点
  6. 将后续节点的ppre指向新申请节点

2、代码实现：

/* 头插法 */
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;
}

（四）链表尾插法

1、步骤：

  1. 申请节点空间
  2. 将数据存放到节点中
  3. 将pnext赋值为空白节点
  4. 将ppre赋值为之前的最后一个节点地址
  5. 将之前最后一个节点的pnext指向新申请节点
  6. 将空白节点的ppre指向新申请节点

2、代码实现：

/* 尾插法 */
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;
}

（六）链表的遍历

1、步骤：与双向链表类似，循环链表最终循环条件由 != NULL修改为 != phea

2、代码实现：

/* 链表节点遍历 */
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;
}

（七）链表的查找

1、步骤：与双向链表类似

2、代码实现：

/* 链表的查找 */
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;
}

（八）链表的修改

1、步骤：与双向链表类似

2、代码实现：

/* 链表的修改 */
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;
}

（九）链表的删除

1、步骤：与双向链表类似

2、代码实现：

/* 链表的删除 */
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);

                        pfreenode = NULL；
                }
                else
                {
                        ptmpnode = ptmpnode->pnext;
                }

        }
        return 0;
}

（十）链表的销毁

1、步骤：与双向链表类似

1、代码实现：

/* 链表的销毁 */
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、概念：

  1. Linux内核中所使用到的一种链表结构
  2. 使用同一种结构可以存储不同类型的链表
  3. 普通链表：链表节点中包含数据
  4. 内核链表：数据中包含链表节点

2、结构：

3、 内核链表、单向链表、双向链表和循环链表 区别与联系

  • 单向链表
    • 由一系列节点组成，每个节点包含数据域和一个指向下一个节点的指针。
    • 节点之间的连接是单向的，只能从链表头开始，沿着指针依次访问后续节点，无法反向遍历。
  • 双向链表
    • 同样由节点构成，每个节点除了包含数据域和指向下一个节点的指针外，还包含一个指向前一个节点的指针。
    • 可以从链表头向链表尾遍历，也可以从链表尾向链表头遍历，增加了遍历的灵活性。
  • 循环链表
    • 可以是单向循环链表或双向循环链表。在单向循环链表中，最后一个节点的指针指向链表头节点；在双向循环链表中，头节点的前驱指针指向尾节点，尾节点的后继指针指向头节点。
    • 形成一个封闭的环，使得遍历可以无限循环下去。
  • 内核链表
    • 是 Linux 内核中使用的一种链表实现方式，它将链表节点嵌入到其他数据结构中。节点只包含两个指针（前驱和后继），不包含数据域。
    • 通过这些指针将不同的数据结构连接成链表，使得链表操作与具体的数据结构解耦。

数据结构04--双向循环链表详解
weixin_69902486的博客
08-09 914
对链表而言，双向均可遍历是最方便的，另外首尾相连循环遍历也可大大增加链表操作的便捷性。因此，双向循环链表，是在实际运用中是最常见的链表形态。
数据结构--双向链表
m0_62706197的博客
06-24 1239
为了和前几篇文章的链表做比较，双向链表结构体也尽量定义相似的。// 前驱指针// 后驱指针。
Java数据结构--双向链表
m0_74808313的博客
04-23 2200
在上一篇中我们学习了单向链表的实现，链表中我们除了单向链表还有双向链表，在这一篇我们将更进一步地了解链表，实现双向链表。
【数据结构】--- 双向链表
khazix101的博客
10-23 1089
无头双向循环链表的实现
数据结构--双向链表（图文）
SouTY_C的博客
06-26 1328
双向链表相较于单链表的优势在于可以快速访问和操作节点的相邻元素，尤其在需要频繁插入或删除元素的场景中，它提供了更高效的数据操作方式。双向链表常用于实现高级数据结构，如栈、队列、列表等，并且在某些编程语言的标准库中，如C++的STL和Java的LinkedList，都提供了双向链表的实现。双向链表在每个节点处都维护了两个指针，一个指向前一个节点（称为前驱节点），另一个指向下一个节点（称为后继节点）。：头节点的后继指针指向尾节点，尾节点的前驱指针又指回头节点，这样的双向链表形成一个环。情况一：链表只有头节点。
01数据结构-双向循环链表及实现
2302_82136376的博客
07-28 874
今天我们来写链表当中的最后一个结构：双向链表。这里我直接讲一下最常用的链表：双向循环链表。之前写的单向链表大家可以想一下有个什么样的缺点？这个缺点很明显，开弓没有回头箭，一旦往后走了就再也回不去了。在工程中，如果没有特殊情况，一般也不会用单向链表，因为很不灵活，反倒用双向链表，很灵活，往前走也行，往后走也行。在双向链表插入，删除中我们不再需要找到前一个节点，找到自己的节点即可。在C++STL中有个数据结构叫list，这个list就是我们今天讲的双向循环链表。
数据结构-循环链表和双向链表
pyc68的博客
06-29 3204
本篇文章介绍数据结构中的循环链表和双向链表
数据结构-带头双向循环链表
2302_79539362的博客
12-02 3332
数据结构-带头双向循环链表
【数据结构】链表--双向链表
Skrrapper的博客
05-21 1088
双向链表每个元素都是一个对象，每个对象包括一个数据域和两个指针域next和prev。我们知道，单链表可以从后往前轻松的前进，但是它很难实现后退。它一般只能从头到尾或者从尾到头。那么当我们需要实现更加灵活的操作时，就可以使用双向链表：拥有两个指针域，一个指向前驱节点，一个指向后继节点，在操作时既可以前进也可以后退，灵活性大大提高。双向链表的操作普遍上比单向链表简单，因为它多了一个指针域所以操作的灵活性大大提高。如果头指针指向自己，那么此时的链表就自然是一个空表，完成双向链表的初始化。
初阶数据结构-----双向链表的实现
2402_83215991的博客
10-04 778
双向链表的结构：节点的数据、指向上一个节点的指针、指向下一个节点的指针我们所说的双向链表的全称其实是“带头双向循环链表”，而单链表的全称则是“不带头单向不循环链表带头：带头指的是当双向链表为空时，此时链表只剩一个头节点；而单链表为空时，就仅仅是一个空链表（在这所谓的头节点跟单链表的头结点不是一个含义，这里的头结点是叫作哨兵位，这个哨兵位没有过多的理解，只是用来充当一个头节点，它所存在的意义是遍历循环链表避免死循环）
数据结构 -- 双向链表
酷酷学!!!的博客
04-29 1534
双向链表是一种常见的数据结构，它与单向链表相比，在存储元素的同时还记录了元素的前驱节点。双向链表可以实现双向遍历，不仅可以从头到尾遍历元素，还可以从尾到头遍历。这种特性使得双向链表在某些场景下更加方便和高效。在双向链表中，每个节点都有两个指针，一个指向前驱节点，一个指向后继节点。这样，我们可以通过前驱指针和后继指针，方便地进行插入、删除、查找等操作。在接下来的文章中，我们将详细讨论双向链表的实现和常见操作。我们将逐步介绍双向链表的构造、插入、删除、查找等操作，并给出相应的代码示例。
数据结构--双向循环链表实践
07-18
c语言实现：利用双向循环链表，用户输入一个数使得26个字母的排列发生变化，例如用户输入3，输出结果：DEFGHIJKLMNOPQRSTUVWXYZABC
漫话数据结构-双向链表及基本操作.pptx
11-03
"漫话数据结构-双向链表及基本操作"的讲座涵盖了双向链表的概念、构建、插入和删除操作，以及双向循环链表的特性。这些知识对于理解和掌握数据结构的基础至关重要，同时也是提升编程技能和解决实际问题能力的重要...
算法-数据结构和算法-8-双向链表.rar
09-16
本资源"算法-数据结构和算法-8-双向链表.rar"聚焦于一种常用的数据结构——双向链表。双向链表是链式存储结构的一种，与单向链表相比，它具有更多的灵活性和便利性。 双向链表的每个节点不仅包含数据元素，还包含两...
数据结构2.（双向链表，循环链表及内核链表）
2401_89312016的博客
08-05 586
本文详细介绍了三种链表的实现方法：双向链表、循环链表和内核链表。双向链表部分包含节点定义、创建、头插/尾插法、遍历、查找、修改、删除等操作实现；循环链表在双向链表基础上增加了循环特性，调整了遍历条件；内核链表部分分析了Linux内核中的链表实现，包括节点定义、初始化、插入/删除操作以及各类遍历宏定义。全文通过代码示例展示了链表的核心操作，重点比较了不同链表类型在实现上的差异，特别是循环链表和内核链表在结构设计和操作实现上的优化技巧。
数据结构04 栈和队列
最新发布
LI1109hd的博客
08-05 218
/队列: 先进先出。
【数据结构初阶】--顺序表（二）
yhrxh_ymq的博客
08-05 803
本文详细讲解了顺序表的实现方法，重点介绍了尾插、头插、尾删和头删四个核心操作。内容包含：1）尾插操作的动态扩容机制，采用2倍扩容策略；2）头插操作需要整体后移元素；3）尾删只需修改size值；4）头删需要前移元素。文中提供了完整的C语言实现代码，并通过测试用例验证了各功能的正确性。最后分析了时间复杂度：尾插/删为O(1)，头插/删为O(n)，说明顺序表更适合频繁操作尾部数据的场景。作者预告后续将继续完善顺序表的其他操作接口。
排序算法-快速排序
Shenqialong的博客
08-02 443
快速排序摘要 快速排序是一种基于分治策略的高效排序算法，由Tony Hoare于1960年提出。其核心思想是：1)选择基准值；2)将数组划分为小于和大于基准值的两部分；3)递归排序子数组。Go语言实现展示了基础版本（时间复杂度O(n log n)）和优化版本（采用随机基准、三路分区和小数组插入排序优化）。算法演示版本详细展示了排序过程的分区和递归步骤。快速排序在实际应用中性能优异，是常用的排序算法之一。
数据结构：在链表中插入节点（Inserting in a Linked List）
2402_88047672的博客
08-03 877
本文讲解了在链表中插入节点的原理和实现方法。链表插入通过修改指针连接完成，相比数组更高效。插入分为三种情况：表头插入需更新头指针；中间插入需找到前驱节点并调整两个指针；尾部插入需遍历到末尾节点。文章详细分析了指针操作逻辑，并给出了C语言实现代码，包括处理边界条件（如越界检查）和内存管理。通过示例演示了如何在不同位置插入节点，最终构建出完整的链表结构。实现关键在于正确操作节点指针的指向关系。
数据结构-双向循环链表
10-23
双向循环链表是一种链式存储结构，它的每个节点都有两个指针，一个指向前驱节点，一个指向后继节点。与单向链表不同的是，双向循环链表的尾节点的后继节点指向头节点，头节点的前驱节点指向尾节点，形成一个环形结构。这种结构的好处是可以方便地在链表中进行前后遍历，而不需要像单向链表那样记录前驱节点。在双向循环链表中，插入和删除操作比较灵活，可以在任意位置进行操作。 双向循环链表的节点结构包含三个部分：数据域、前驱指针和后继指针。其中，前驱指针指向前一个节点，后继指针指向后一个节点。在双向循环链表中，头节点的前驱指针指向尾节点，尾节点的后继指针指向头节点。 双向循环链表的插入操作包括在链表头插入、在链表尾插入和在链表中间插入三种情况。删除操作也包括在链表头删除、在链表尾删除和在链表中间删除三种情况。在进行插入和删除操作时，需要注意指针的指向关系，以保证链表的正确性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值