数据结构学习——双向链表

最新推荐文章于 2025-08-05 20:11:32 发布
原创 最新推荐文章于 2025-08-05 20:11:32 发布 · 1.1k 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文介绍数据结构学习中的双向链表，包括双向链表的基本概念、双向循环链表的优势和创建方法，以及柔性数组在双向链表中的应用。双向循环链表允许O(1)时间复杂度访问头尾节点，但会增加内存开销。同时，文章提到了柔性数组在结构体中的使用，以及内存分配和释放的注意事项。

数据结构学习记录DAY4：双向链表

双向链表

双向链表简介：

如果认识单向链表，那么双向链表的定义其实非常之简单，只需要在单向链表的基础上，增加一个指向前结点的指针，即——对于任意一个结点，都有一个指向前一个结点和后一个结点的指针。以下为一个基础双向链表的定义。

struct Dnode{
	int elem;
	struct Dnode *prev;
	struct Dnode *next;
}

对于单纯的双向链表来说，头结点不存储数据，头结点的前驱指针（prev）指向NULL，后置指针(next)指向下一个结点，如果没有则指向空。

那么对于不单纯的双向链表来说又如何呢？

所谓不单纯的双向链表，其实就是指的双向循环链表。对其我是这样理解的：对于任意一个拥有头结点以外结点的双向链表，令其最后一个元素的尾指针指向头结点，而头结点的前驱指针指向尾结点，如此就形成了一个循环。
这样做有何益处呢？首先，对于单向链表来说，访问尾结点的时间复杂度为O(n)，但由于双向循环链表有指向尾结点的指针，因此访问的时间复杂度变为O(1)，可以缩减对于元素的访问时间，尤其是头尾两个结点。其次，双向链表可以方便地通过任意一个结点的位置访问到其他的结点，不必受方向的限制。
弊端自然是增加了指针域，内存利用率再次降低，当然空间换时间的买卖由使用者决定值不值。

双向循环链表

头结点 的prev指向最后一个结点，最后一个结点的next指向头结点。

  • 在头部和尾部进行插入和删除的时间复杂度都为O(1)
  • 能直接访问链表的最后一个结点

双向循环链表的创建

#define SUCCESS 0//此处注意后面也要用
#define FAILURE -1
typedef struct Dnode * DL;
#define SIZE_DNODE sizeof(*DL);

DL create_dlinklist(void)
{
    DL list = (DL)malloc(SIZE_DNODE);
    if(NULL != list)
    {
        list->prev = list->next = list;
    }
    return list;
}

双向循环链表的插入

static struct Dnode* create_ndoe(struct Dnode *prev, struct Dnode *next, int elem)
{
	struct Dnode *node = (struct Dnode*)malloc(SIZE_DNODE);
	if(NULL != node)
	{
		node->elem = elem;
		node->prev = prev;
		node->next = next;
	}
	return node;
}
//插入到pos后面的位置
static int insert_after(struct Dnode* node, ElemType elem)
{
    struct Dnode* insnode = create_node(node, node->next, elem);
    if(NULL == insnode)
    {
        return FAILURE;
    }
    node->next->prev = insnode;
    node->next = insnode;
    return SUCCESS;
}
//插入到pos前面的位置
static int insert_before(struct Dnode* node, ElemType elem)
{
    struct Dnode* insnode = create_node(node->prev, node->next, elem);
    if(NULL == insnode)
    {
        return FAILURE;
    }
    node->prev->next = insnode;
    node->prev = insnode;
    return SUCCESS;
}
//正式创建
//前插
int push_front_dlinkedlist(DL list, ElemType elem)
{
    return insert_after(list, elem);
}
//后插
int push_back_dlinkedlist(DL list, ElemType elem)
{
    return insert_before(list, elem);
}
//任意位置插入
int insert_dlinkedlist(DL list, size_t pos, ElemType elem)
{
     assert(NULL != list);
     if(0 == pos)
     {
        return FAILURE;
     }
    struct Dnode *node = get_node(list, pos);
    if(NULL == node)
    {
        return FAILURE;
    }
    return insert_before(node, elem);

}

双向链表的结点删除


int delete_dnode(struct Dnode* node, ElemType *pe)
{
    if(NULL != pe)
    {
        *pe = node->elem;
    }
    node->next->prev = node->prev;
    node->prev->next = node->next;
    free(node);
    return *pe;
}
//头删
int pop_front_dlinkedlist(DL list, ElemType *elem)
{
    assert(NULL != list);
    if(list->next == list)
    {
        return FAILURE;
    }
    return delete_dnode(list->next, elem);
}
//尾删
int pop_back_dlinkedlist(DL list, ElemType *elem)
{
    assert(NULL != list);
    if(list->next == list)
    {
        return FAILURE;
    }
    return delete_dnode(list->prev, elem);
}
//任意位置删
int remove_dlinkedlist(DL list, size_t pos, ElemType *elem)
{
    assert(NULL != list);
    if(0 == pos)
    {
        return FAILURE;
    }
    struct Dnode * node = get_node(list, pos);
    if(NULL == node || list == node)
    {
        return FAILURE;
    }
    return delete_dnode(node, elem);
}

双向链表结点修改

//按位置修改
int update_dlinkedlist(DL list, size_t pos, ElemType newelem)
{
    assert(NULL != list);
    if(0 == pos)
    {
        return FAILURE;
    }
    struct Dnode *node = get_node(list, pos);
    if(NULL == node || list == node)
    {
        return FAILURE;
    }
    node->elem = newelem;
    return SUCCESS;

}
//按元素修改
int update_elem_dlinkedlist(DL list, ElemType oldelem, ElemType newelem, size_t n)
{
    assert(NULL != list);
    struct Dnode *node = list->next;
    size_t cnt = 0;
    for(;node != list; node = node->next)
    {
        if(node->elem == oldelem)
        {
            if(n == 0)
            {
                node->elem = newelem;
            }
            else
            {
                if(--n == 0)
                {
                    node->elem = newelem;
                    return 1;
                }
            }
        }
    }
    return cnt;
    
}
//按条件修改
int update_condition_dlinkedlist(DL list, bool (*condition)(ElemType), ElemType newelem, size_t n)
{
    assert(NULL != list && condition != NULL);
    struct Dnode *node = list->next;
    size_t cnt = 0;
    for(;node != list; node = node->next)
    {
        if(condition(node->elem))
        {
            if(n == 0)
            {
                node->elem = newelem;
            }
            else
            {
                if(--n == 0)
                {
                    node->elem = newelem;
                    return 1;
                }
            }
        }
    }
    return cnt;
}

双向链表查找

//值查找
int find_dlinkedlist(DL list, ElemType elem, size_t n)
{
    assert(NULL != list);
    if(n == 0)
    {
        return 0;
    }
    struct Dnode *node = list->next;
    size_t pos = 0;
    for(;node != list; node = node->next)
    {
        ++pos;
        if(node->elem == elem)
        {
            if(--n == 0)
            {
                return pos;
            }
        }
    }
    return 0;
}
//条件查找
int find_condition_dlinkedlist(DL list, bool (*condition)(ElemType), size_t n)
{
    assert(NULL != list && condition != NULL);
    if(n == 0)
    {
        return 0;
    }
    struct Dnode *node = list->next;
    size_t pos = 0;
    for(;node != list; node = node->next)
    {
        ++pos;
        if(condition(node->elem))
        {
            if(--n == 0)
            {
                return pos;
            }
        }
    }
    return 0;
}

今天还学了一个概念叫柔性数组
GNU/GCC 在标准的 C/C++ 基础上做了有实用性的扩展, 零长度数组（Arrays of Length Zero） 就是其中一个知名的扩展。零长度数组即柔性数组。多数情况下, 其应用在变长数组中, 其定义如下
柔性数组在结构体成员中，最后一个成员是一个数组，长度为0 或不明
struct Dnode{
struct Dnode *prev;
struct Dnode *next;
char elem[];
};

  • 申请内存空间：
    首先, 需为结构体分配一块内存空间;
    其次再为结构体中的成员变量分配内存空间.
    这样两次分配的内存是不连续的, 需要分别对其进行管理
    struct Dnode * node = malloc(sizeof(struct Dnode) + 32);
    同样的在释放时，需要这样分开释放
free(Dnode->elem);
free(Dnode);

这是由于其定义时开辟的内存空间不同导致的

以上！

希望能给你一点帮助。
感谢

标签
#数据结构 #链表 #学习
YiHeboy
关注
数据结构——双向循环链表
wry_sunny_的博客
03-15 800
双向循环链表是一种链式存储结构，它的最后一个结点指向头结点，形成一个环。因此，从循环链表中的任何一个结点出发都能找到任何其他结点。双向循环链表的操作和双向链表的操作基本一致，差别仅仅在于算法中的循环条件有所不同。双向循环链表的头结点的前驱指向最后一个结点，尾结点的后继指向头结点。 注意：双向循环链表中无其他结点，只有头结点时 ，头结点的前驱和后继度指向自身。 1、双向循环链表的存储结构 t...
计算机考研408真题解析（2023-02 双向链表插入操作深度解析）
goodteacher408的博客
07-18 1355
本文以2023年计算机考研408真题中一道经典的双向链表插入操作题为例，深入剖析其核心考点——多步指针操作的顺序与依赖关系。通过详细的步骤分解、C语言代码实现与验证，并结合复杂度分析和实际应用场景，旨在帮助读者彻底理解双向链表插入的机制，掌握指针操作的精髓，并有效规避常见陷阱。
数据结构与算法(七）--双向链表
qq_37504771的博客
03-16 732
双向链表 如何求链表中p结点的直接前驱，其时间性能如何？ 从当前结点循环遍历判断p结点的直接前驱，时间复杂度为O(n)。 通过p->next可以直接访问p结点的后继结点，时间复杂度为O(1)。 如何快速获取p结点的前驱结点？ 通过结点添加指针域指向前驱结点。 双链表：在单链表的每个结点中在设置一个指针域，指向其前驱结点. data:存放数据元素； next：存放该节点...
客观题测试-第2章线性表
a61233的博客
10-23 1万+
由于链表的元素在内存中是分散存储的，访问特定元素需要从链表的头部开始逐个遍历节点，直到找到目标元素为止，因此链表不适用于随机存取。但是，链表在插入和删除元素方面具有优势，因为只需要修改指向目标元素的前一个节点的指针即可，无需移动其他元素。这是因为顺序存储方式需要在指定的位置插入或删除元素，而这个位置需要通过一定的计算才能得到，所以插入和删除的效率较低。因此，这个说法是错误的。3、在顺序表上可以从前向后顺序访问，也可以从后向前访问，还可以按元素序号随机访问，因此从查找的角度来看，顺序表比链表更灵活。
【C语言】链表入门（配图）
2301_77133706的博客
03-22 2137
本人对于C语言中链表的浅层认识
数据结构学习笔记二：双向链表
ccystewart的博客
05-01 170
数据结构学习笔记二：双向链表 双向链表 双向链表(双链表)是链表的一种。和单链表一样，双链表也是由节点组成，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 表头为空，表头的后继节点为"节点10"(数据为10的节点)；“节点10"的后继节点是"节点20”(数据为10的节点)，“节...
【学习嵌入式day-17-数据结构-单向链表/双向链表】
最新发布
weixin_47152578的博客
08-05 1178
/存放数据的类型//存放数据//指向前一个节点的指针//指向后一个节点的指针}linknode;
数据结构学习：双向链表
m0_62947723的博客
06-25 935
该元素需要变成第一个元素，故该元素的next应指向倒数第二个元素，prev则置空，到此整个表中元素完成逆序，最后head指向该元素则完成了双向链表的逆序。
嵌入式培训之数据结构学习（四）双向链表、makefile
weixin_63557265的博客
05-15 1526
双向链表示意图指针永远指向内存开始的区域。
数据结构双向链表学习
fengjuju的博客
05-02 1432
目录 一.双链表 二.代码展示 1.双向链表的定义 2.双向链表的初始化 3.双向链表在指定位置插入新元素 4.双向链表删除指定元素 5.找到指定元素的位置 6.打印链表长度 7.双向链表的整表删除 8.返回指定结点的地址 9.完整代码 10.样例测试输出 三.总结 一.双链表 双链表对比于单链表添加了一个前驱指针域，优势是可以实现双向遍历，而单链表只能从头结点开始遍历。 学生作业，大佬路过有误请指正。 二.代码展示 1.双向链表的定义 /** * Do
[数据结构] 双向带头链表的学习
dh15834384655的博客
02-23 959
1.带头可能对初学者来说是一种优势,因为有了头(哨兵位),不需要运用二级指针,因为第一的位置已经确定,(二级指针用在不带头的修改头的值), 相对来说可能更加好理解,但是带头,这个头哨兵位存储的数据却没有很大的意义,实践意义并不大.2.双向的链表,有一个好处,解决了单链表不能够找到前一个的问题,链表之间形成了循环,数据的修改更加便捷,当然相对而言也是更加复杂的.// 双向链表在pos的前面进行插入。// 双向链表删除pos位置的节点。//链表pos位置之前的插入。//链表pos位置的删除。
数据结构学习分享之双向链表详解
杭电码农-NEO的博客
05-03 1518
双向链表详解
数据结构 | 双向链表学习总结
lovetaozibaby的博客
09-24 719
双向链表学习总结简介双向链表数据结构力扣第430题：扁平化多级双向链表 简介 摘自：通俗易懂讲解 链表 单向链表： 双向链表： 看图理解吧。。。 双向链表数据结构 摘自： 数据结构-双向链表（Python实现） 数据结构在编程世界中一直是非常重要的一环，不管是开发还是算法，哪怕是单纯为了面试，数据结构都是必修课，今天我们介绍链表中的一种——双向链表的代码实现。 双向链表： class Node: def __init__(self, data): self.data = data
数据结构学习，双向链表
好好学习的博客
01-31 1415
目录 预先要引用的头文件以及宏定义 所使用双向链表的结构 其基本操作接口 初始化双向链表 销毁双向链表 双向链表L置空 双向链表L判空 求双向链表L的长度 查找。返回双向链表L中第一个数据域值为e的结点地址，若不存在则返回NULL 返回p结点的直接前驱的指针，若p结点是头结点则返回NULL 返回p结点的直接后继的指针，若p结点是尾结点则返回NULL 分配一个数据域为e的结点，返回该结点的指针 在p结点前插入q 在p结点后插入q 删除p所指向的结点，并用参数e返回p的元素值 遍历双向链表L 一些接口的测试
Java学习——数据结构——双向链表
qq_41853002的博客
03-28 195
学习尚硅谷韩顺平老师的Java数据结构笔记，详情请移步网站 双向链表的操作分析和实现 使用带 head 头的双向链表实现 管理单向链表的缺点分析: 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。 单向链表不能自我删除，需要靠辅助节点 ，而双向链表，则可以自我删除，所以前面单链表删除结点时，总是找到 temp,temp 是待删除节点的前一个节点. 分析了双向链表如何完成遍历，...
数据结构学习之双向链表结构
热门推荐
落魄影子
12-10 2万+
注：本文的主要目的是为了记录自己的学习过程，也方便与大家做交流。转载请注明来自： http://blog.csdn.net/ab198604           在前面总结的单向链表结构的基础上，现在开始着手实践实践双向链表结构，如果充分理解了单向链表数据结构，那对双向链表结构的理解也就不再困难，换个角度而言，双向链表是单向链表的扩展，如果从数据结构代码的定义上来看，双向链表需要维护三个数据
数据结构学习总结 线性表之双向链表
weixin_30642869的博客
05-07 372
　　目前我们所学到的链表，无论是动态链表还是静态链表，表中各节点中都只包含一个指针（游标），且都统一指向直接后继节点，通常称这类链表为单向链表（或单链表）。 虽然使用单链表能 100% 解决逻辑关系为 "一对一" 数据的存储问题，但在解决某些特殊问题时，单链表并不是效率最优的存储结构。比如说，如果算法中需要大量地找某指定结点的前趋结点，使用单链表无疑是灾难性的，因为单链表更适合...
算法学习之数据结构之双向链表
逆风奔跑。。不要去考虑什么天赋异禀，一切都来自经历和渴望。
09-06 1462
双链表的没一个元素都是对象，每个对象包含一个关键字域和两个指针域（next，prev）。当然，每个对象还可能包含一些其他的卫星数据。next指向后继节点，prev指向前驱节点。如果prev[x] == null，则无前驱节点，是head头节点。如果next[x] == null则无后继节点，是最后一个节点，即尾节点tail。 　　双链表的具体操作如下： 双向链表的插入：insert(L
数据结构学习记录-双向链表
jhbuy的博客
01-17 982
带头双向循环链表是链表中带头（哨兵位）、双向、循环三种属性的结合体；带头即带哨兵位，哨兵位只负责存储第一个具有有效数据的节点，本身不存放数据，该处因为为双向循环链表，代表也可访问该链表的尾节点；双向即表示，每个节点不仅能访问该节点的后一个节点，同时也可访问本节点的前一个节点；循环即表示，第一个节点的prev指向尾节点带头双向循环链表虽然在结构中是所有链表中最为复杂的，但是相比较于单链表的优势在于不需要多次对链表为空进行判断，避免了边界问题；
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值