【数据结构】双向链表及其基本操（带图详解）

已于 2023-11-11 00:12:01 修改
阅读量504 收藏 2
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 链表
于 2023-11-10 12:58:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z1tai/article/details/134330272
版权

文章目录

双向链表（Doubly Linked List）及其基本操作

1. 简介

双向链表是一种常见的线性数据结构，它与单向链表相比具有双向遍历的优势。除了拥有指向后继节点的指针外，双向链表还拥有指向前驱节点的指针。这使得在双向链表中可以更有效地实现从后往前的遍历，而不像单向链表那样需要重新遍历整个链表。在某些场景下，双向链表能够更加高效地解决问题。
在这里插入图片描述

2. 创建双向链表

2.1 结构声明

#include<bits/stdc++.h>
using namespace std;

typedef int LTDataType;
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* next;
	struct ListNode* prev;
}ListNode;

2.2 初始化双向链表(Init)

// 创建一个带头结点的双向循环链表
ListNode* ListInit() {
    ListNode* head = (ListNode*)malloc(sizeof(ListNode)); // 分配头结点内存空间
    head->data = -1; // 设定头结点数据为-1
    head->next = head; // 头结点的下一个指向自己，形成循环
    head->prev = head; // 头结点的上一个指向自己，形成循环
    return head; // 返回头结点
}

2.3 创建双向链表节点

// 创建一个新结点
ListNode* ListCreate(LTDataType x) {
    ListNode* newnode = (ListNode*)malloc(sizeof(ListNode)); // 分配新结点内存空间
    if (!newnode) {
        perror("fail"); // 内存分配失败则输出错误信息
        exit(-1); // 退出程序
    }

    newnode->data = x; // 设置新结点的数据
    newnode->next = NULL; // 设置新结点的下一个为NULL
    newnode->prev = NULL; // 设置新结点的上一个为NULL

    return newnode; // 返回新结点
}

2.4 插入节点(Insert)

在双向链表中，由于每个节点都有指向其前一个节点和后一个节点的引用，因此可以更高效地在任意位置插入或删除节点，而不需要像单链表那样遍历查找前一个节点。
在这里插入图片描述
关键在于它们的顺序，由于第②步和第③步都用到了p->next。如果第④步先执行，则会使得p->next提前变成了s，使得插入的工作完不成。所以我们不妨把上面这张图在理解的基础上记忆，顺序是先搞定s的前驱和后继，再搞定后结点的前驱，最后解决前结点的后继。
在这里插入图片描述

// 在特定位置插入元素
void ListInsert(ListNode* pos, LTDataType x) {
    assert(pos); // 检查位置是否存在
    ListNode* newnode = ListCreate(x); // 创建新结点

    newnode->next = pos; // 新结点的下一个指向位置结点
    pos->prev->next = newnode; // 位置结点的上一个的下一个指向新结点
    newnode->prev = pos->prev; // 新结点的上一个指向位置结点的上一个
    pos->prev = newnode; // 位置结点的上一个指向新结点
}

2.5 查找结点（Find)

定义了一个名为p的结构体指针，并初始化为指向双链表中的头节点之后的第一个元素。然后，该函数会遍历整个双链表， 当p指向的数据等于给定的值x时，立即返回p。否则，继续将p向后移动一位。一旦p重新回到头节点，循环结束且并未找到匹配项，则返回NULL。

// 查找特定元素
ListNode* ListFind(ListNode* head, LTDataType x) {
    assert(head); // 检查头结点是否存在

    ListNode* p = head->next; // 从头结点的下一个开始

    while (p != head) { // 遍历链表直到回到头结点
        if (p->data == x) // 如果找到了相同的数据
            return p; // 返回该结点
        p = p->next; // 移动到下一个结点
    }
    return NULL; // 如果未找到则返回NULL
}

2.6 删除节点(Erase)

在双向链表中，删除节点时不需要像单链表那样遍历查找前一个节点，因为每个节点都有指向前一个节点的引用，所以可以更高效地进行删除操作。

在这里插入图片描述
我们要删除指定位置，可以定义一个结构体指针pre保存要删除位置的前一个位置，定义一个结构体指针next保存要删除位置的后一个位置。然后free掉pos，让pre的next指向next，让next的prev指向pre。

// 删除特定位置的元素
void ListErase(ListNode* pos) {
    assert(pos); // 检查位置是否存在

    ListNode* pre = pos->prev; // 找到位置结点的上一个
    ListNode* next = pos->next; // 找到位置结点的下一个

    pre->next = next; // 位置结点的上一个的下一个指向位置结点的下一个
    next->prev = pre; // 位置结点的下一个的上一个指向位置结点的上一个
    free(pos); // 释放位置结点
    pos = NULL; // 将位置结点置为NULL
}

2.7 打印双向链表

// 打印链表
void ListPrint(ListNode* head) {
    ListNode* p = head->next; // 从头结点的下一个开始
    if (p == head) // 如果下一个是头结点则说明链表为空
        cout << "NULL"; // 打印NULL
    while (p != head) { // 遍历链表直到回到头结点
        cout << p->data << "->"; // 打印结点数据
        p = p->next; // 移动到下一个结点
    }
    cout << endl; // 换行
}

2.8 销毁双链表

我们需要释放整个双链表，所以我们需要从第一个节点开始遍历列表。我们将当前节点和下一个节点分别存储在cur和q(保存下一个结点)中。每次迭代都将当前节点设置为下一个节点，直到遍历到头节点为止。此时，我们会释放掉最后一个未被释放的节点并返回。

// 销毁链表
void ListDestory(ListNode* head) {
    assert(head); // 检查头结点是否存在
    ListNode* p = head->next; // 从头结点的下一个开始

    while (p != head) { // 遍历链表直到回到头结点
        ListNode* q = p->next; // 保存下一个结点
        free(p); // 释放当前结点内存
        p = q; // 移动到下一个结点
    }

    free(head); // 释放头结点内存
}

3. 总代码

#include<bits/stdc++.h>
using namespace std;

typedef int LTDataType;
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* next;
	struct ListNode* prev;
}ListNode;

```cpp
// 创建一个带头结点的双向循环链表
ListNode* ListInit() {
    ListNode* head = (ListNode*)malloc(sizeof(ListNode)); // 分配头结点内存空间
    head->data = -1; // 设定头结点数据为-1
    head->next = head; // 头结点的下一个指向自己，形成循环
    head->prev = head; // 头结点的上一个指向自己，形成循环
    return head; // 返回头结点
}

// 创建一个新结点
ListNode* ListCreate(LTDataType x) {
    ListNode* newnode = (ListNode*)malloc(sizeof(ListNode)); // 分配新结点内存空间
    if (!newnode) {
        perror("fail"); // 内存分配失败则输出错误信息
        exit(-1); // 退出程序
    }

    newnode->data = x; // 设置新结点的数据
    newnode->next = NULL; // 设置新结点的下一个为NULL
    newnode->prev = NULL; // 设置新结点的上一个为NULL

    return newnode; // 返回新结点
}

// 打印链表
void ListPrint(ListNode* head) {
    ListNode* p = head->next; // 从头结点的下一个开始
    if (p == head) // 如果下一个是头结点则说明链表为空
        cout << "NULL"; // 打印NULL
    while (p != head) { // 遍历链表直到回到头结点
        cout << p->data << "->"; // 打印结点数据
        p = p->next; // 移动到下一个结点
    }
    cout << endl; // 换行
}

// 在链表末尾插入元素
void ListPushBack(ListNode* head, LTDataType x) {
    assert(head); // 检查头结点是否存在

    ListNode* newnode = ListCreate(x); // 创建新结点

    ListNode* tail = head->prev; // 找到链表末尾结点

    tail->next = newnode; // 末尾结点的下一个指向新结点
    newnode->prev = tail; // 新结点的上一个指向末尾结点
    newnode->next = head; // 新结点的下一个指向头结点
    head->prev = newnode; // 头结点的上一个指向新结点
}

// 删除链表末尾元素
void ListPopBack(ListNode* head) {
    assert(head); // 检查头结点是否存在
    assert(head->next != head); // 检查链表是否非空

    ListNode* tail = head->prev; // 找到链表末尾结点

    head->prev = tail->prev; // 头结点的上一个指向末尾结点的上一个
    tail->prev->next = head; // 末尾结点的上一个的下一个指向头结点

    free(tail); // 释放末尾结点内存
    tail = NULL; // 将末尾结点置为NULL
}

// 在链表开头插入元素
void ListPushFront(ListNode* head, LTDataType x) {
    assert(head); // 检查头结点是否存在

    ListNode* next = head->next; // 找到头结点的下一个

    ListNode* newnode = ListCreate(x); // 创建新结点

    newnode->next = next; // 新结点的下一个指向原先的第一个结点
    next->prev = newnode; // 原先的第一个结点的上一个指向新结点

    head->next = newnode; // 头结点的下一个指向新结点
    newnode->prev = head; // 新结点的上一个指向头结点
}

// 删除链表开头元素
void ListPopFront(ListNode* head) {
    assert(head); // 检查头结点是否存在
    assert(head->next != head); // 检查链表是否非空

    ListNode* p = head->next; // 找到第一个结点
    ListNode* next = p->next; // 找到第一个结点的下一个结点

    head->next = next; // 头结点的下一个指向第一个结点的下一个
    next->prev = head; // 第一个结点的下一个的上一个指向头结点

    free(p); // 释放第一个结点内存
    p = NULL; // 将第一个结点置为NULL
}

// 查找特定元素
ListNode* ListFind(ListNode* head, LTDataType x) {
    assert(head); // 检查头结点是否存在

    ListNode* p = head->next; // 从头结点的下一个开始

    while (p != head) { // 遍历链表直到回到头结点
        if (p->data == x) // 如果找到了相同的数据
            return p; // 返回该结点
        p = p->next; // 移动到下一个结点
    }
    return NULL; // 如果未找到则返回NULL
}

// 在特定位置插入元素
void ListInsert(ListNode* pos, LTDataType x) {
    assert(pos); // 检查位置是否存在

    ListNode* newnode = ListCreate(x); // 创建新结点

    newnode->next = pos; // 新结点的下一个指向位置结点
    pos->prev->next = newnode; // 位置结点的上一个的下一个指向新结点
    newnode->prev = pos->prev; // 新结点的上一个指向位置结点的上一个
    pos->prev = newnode; // 位置结点的上一个指向新结点
}

// 删除特定位置的元素
void ListErase(ListNode* pos) {
    assert(pos); // 检查位置是否存在

    ListNode* pre = pos->prev; // 找到位置结点的上一个
    ListNode* next = pos->next; // 找到位置结点的下一个

    pre->next = next; // 位置结点的上一个的下一个指向位置结点的下一个
    next->prev = pre; // 位置结点的下一个的上一个指向位置结点的上一个
    free(pos); // 释放位置结点
    ```cpp
    pos = NULL; // 将位置结点置为NULL
}

// 销毁链表
void ListDestory(ListNode* head) {
    assert(head); // 检查头结点是否存在

    ListNode* p = head->next; // 从头结点的下一个开始

    while (p != head) { // 遍历链表直到回到头结点
        ListNode* q = p->next; // 保存下一个结点
        free(p); // 释放当前结点内存
        p = q; // 移动到下一个结点
    }

    free(head); // 释放头结点内存
}

结论

双向链表提供了更多的灵活性，能够支持更多的操作，但相应地也会占用更多的内存空间。在需要频繁进行双向遍历的场景下，双向链表是一个非常实用的数据结构。

SuhyOvO
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
数据结构-链表结构-双向链表
qq_44715376的博客
08-01 3206
双向链表
数据结构 双向链表的创建和读取详解及实例代码
12-26
数据结构 双向链表的创建和读取 双向链表是为了满足更加方便的查找前驱，而付出空间的代价的一个数据结构。双向链表的节点定义如下： typedef struct node { int x; struct node *prior,*next; }DLNode; 双向...
双向链表（Double Linked List）
热门推荐
Hacket_Xu的博客
08-28 1万+
虽然单向链表能够100%解决逻辑关系为“一对一”数据的存储问题，但在解决那些需要大量查找前趋节点的问题是，单向链表无疑是不能用了，因为单向链表适合“从前往后”查找，并不适合“从后往前”查找。如果要提高链表的查找效率，那双向链表（双链表）无疑是首选。双向链表字面上的意思是“双向”的链表，如图1所示。图1 - 双向链表示意图双向指各个节点之间的逻辑关系是双向的，该链表通常只有一个头节点。......
数据结构——双向链表（保姆级教程，包学包会）
m0_74459304的博客
05-14 6637
1.双向链表的概念 双向链表就是带头双向循环链表 我们在学完单链表之后，就感觉这个非常简单了，他的主要表现就是拥有头节点，链表永不为空，不需要二级指针；可以通过一个节点找到上一个或者下一个节点；头尾相连呈环状。 他主要结构是由prev、next、data，这三个结构组成，通过prev找到前一个节点，next就不用多说了。
数据结构-双链表(图解)
最新发布
2302_78381559的博客
04-20 1375
双链表是一种常用且重要的线性数据结构，它在计算机科学和软件工程中扮演着不可或缺的角色。相较于单链表，双链表的每个节点包含两个指针，分别指向其前驱节点（previous node）和后继节点（next node），这一特性使得双链表在数据操作上具有更高的灵活性。
【数据结构】双向链表
m0_73648729的博客
06-28 5767
和单向链表一样，双向链表每个节点都是由结构体组成的数据类型，但是双向链表结构体中增加了一个指向前一个节点的指针。//方便修改数据类型//指向下一个节点的指针//指向前一个节点的指针//存储的数据}LTNode;我们今天要将的是带哨兵卫头节点的双向循环链表，它的头节点不存储有效数据，头节点中的prev指针指向最后一个节点。
双向链表详解
m0_74859835的博客
06-02 2641
顾名思义，就是在头节点之前插入一个节点，并将其变成头节点。2. 看下标是不是头节点，尾节点，是的话直接调用头插法，尾插法。2. 判断是不是头节点，如果是且不只有一个元素。1. 要先判断他输入的下标合不合法。遍历链表 - 将所有值置为空。1. 先找到key所在的位置。
C#数据结构之双向链表(DbLinkList)实例详解
09-03
主要介绍了C#数据结构之双向链表(DbLinkList),结合实例形式较为详细的讲解了双向链表的概念及C#实现双向链表的相关技巧,具有一定参考借鉴价值,需要的朋友可以参考下
C语言数据结构 双向链表的建立与基本操作
08-31
主要介绍了C语言数据结构 双向链表的建立与基本操作的相关资料,需要的朋友可以参考下
数据结构 —— 双向链表（超详细图解 & 接口函数实现）
十里坡小白的博客
08-08 6160
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。博主将会用代码结合大量图解，对数据结构进行深度剖析。
数据结构——双向链表
aqlll_的博客
05-14 1571
双向链表的介绍和实现代码
链表------双向链表详解
weixin_51134816的博客
05-05 1577
双链表在增删改查方面比单链表方便很多，但在存储空间方面，单链表是比双链表更优的，根据场景不同，两种链表都能发挥出其优点。在学习链表方面，还是要注意区分头指针和头结点！不懂就查，不懂就问，不会就多练！
数据结构 双向链表及其基本操作
Mi-ronin的博客
03-17 7129
双向链表的一系列操作讲解及代码
数据结构—双向链表的基本操作
小虾米编程
06-20 7657
1.双向链表的操作 双向链表的基本操作包括：判断链表是否为空、计算链表的长度、遍历链表，这3中操作的方法和单链表一样，主要和双向链表中的指向后继的指针有关。 双向链表的插入和删除操作和单链表是有区别的：双向链表的插入和删除操作要修改指向前驱和指向后继的指针。 2.双向链表的删除：删除指定位置 i 的元素 1.判断输入的删除的位置是否合法，1<=i<=表长 2.顺着指向后继的指针...
数据结构之链表详解(2)——双向链表
weixin_69283129的博客
08-29 8986
C语言版万字详解：数据结构之链表详解(2)——双向链表的结构和功能实现
【数据结构--双链表】
qq_61719813的博客
05-04 3289
文章目录双向链表双向链表的定义双向链表的存储结构双向链表的初始化双向链表的插入双向链表的删除寻找尾结点正向打印反向打印链表节点的读取测试运行截图完整代码闵版代码（略改）总结 双向链表 双向链表的定义 什么是双向链表？ 双向链表顾名思义，就是链表由单向的链变成了双向链。双向链表(double linked list)是在单链表的每个结点中再设置一个指向其前驱结点的指针域。 非空带头结点的双向链表 双向链表的存储结构 //双链表节点结构体 typedef struct DoubleLinkNode {
【数据结构】--双向链表
m0_74044018的博客
04-15 916
1、主要讲述了双向循环链表的实现细节 2、再述了顺序表和链表的优缺点
双向链表的基本操作c
09-05
在C语言中，实现双向链表的基本操作包括链表的初始化、创建、查询、删除和释放。链表的查询和删除操作可以按照值或者按照结点的序号进行。 对于链表的初始化，可以创建一个空链表，将头指针和尾指针都指向NULL，表示链表为空。 链表的创建可以通过不断插入新的结点来实现。可以从头部或者尾部插入新的结点，并更新头指针和尾指针。 链表的查询操作可以按照值进行，遍历链表，找到目标值所在的结点。也可以按照结点的序号进行，从头结点开始顺序遍历到目标序号的结点。 链表的删除操作也可以按照值进行，遍历链表，找到目标值所在的结点并删除。也可以按照结点的序号进行，从头结点开始顺序遍历到目标序号的结点并删除。 最后，链表的释放操作可以遍历链表，逐个释放每个结点所占用的内存空间。 需要注意的是，双向链表相对于单向链表来说，每个结点都有指向前一个结点和后一个结点的指针，使得在插入和删除操作上更加灵活和方便。 另外，在实际应用中，链表的结构可以根据需求选择不同的组合，如单向带头、不带头循环、非循环等。其中，带头双向循环链表是最常用的链表结构，因为它的结构复杂，但是在实现时具有很多优势。而无头单向非循环链表则更多用于其他数据结构的子结构，如哈希桶、图的邻接表等。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [双向链表及其基本操作](https://download.csdn.net/download/qq_43355070/13074056)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *2* *3* [C语言详解双向链表的基本操作](https://blog.csdn.net/qq_61386381/article/details/124789295)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

SuhyOvO

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值