数据结构：双向链表

已于 2024-07-31 23:53:26 修改
阅读量530 收藏 12
点赞数 14
分类专栏： 数据结构 文章标签： 数据结构 链表
于 2024-07-17 18:15:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74150890/article/details/140499652
版权

目录

一、【双向链表】

1.  定义

2. 双向链表与单向链表的区别

 单向链表

 双向链表

3.  优缺点

 优点

 缺点

二、【 双向链表的接口实现】

1. 创建双向链表

2. 销毁双向链表

3. 双向链表打印

4. 双向链表尾插

5. 双向链表尾删

6. 双向链表头插

7. 双向链表头删

8. 双向链表查找

9. 双向链表在pos的前面进行插入

10. 双向链表删除pos位置的结点

三、【完整代码】

一、【双向链表】

1.  定义

双向链表是一种常见的数据结构，它允许在链表中的元素之间双向移动。双向链表中的每个节点都包含指向前一个节点和后一个节点的指针。

// 定义双向链表节点结构体
typedef struct Node 
{
    int data;           // 节点数据
    struct Node* prev;  // 指向前一个节点的指针
    struct Node* next;  // 指向下一个节点的指针
} Node;

2. 双向链表与单向链表的区别

双向链表和单向链表之间的主要区别在于节点内部指针的数量和方向。

 单向链表

  • 定义：单向链表中的每个节点包含一个指针，该指针指向下一个节点。
  • 遍历：只能从头节点开始，沿着指针的方向依次向后遍历，无法反向遍历。
  • 插入和删除：在单向链表中，如果要在某个节点之后插入一个新节点，需要修改前一个节点的指针，而删除节点时需要修改前一个节点的指针指向被删除节点的下一个节点。

 双向链表

  • 定义：双向链表中的每个节点包含两个指针，一个指向前一个节点，一个指向后一个节点。
  • 遍历：可以从头节点或尾节点开始，沿着相应的指针方向进行遍历，因此可以双向遍历。
  • 插入和删除：在双向链表中，插入和删除节点时不需要修改前一个节点的指针，因为每个节点都有指向前一个节点的指针，这使得插入和删除操作更加高效。 

3.  优缺点

 优点

  1. 双向遍历：双向链表可以从头部向尾部或者从尾部向头部进行遍历，这使得在某些情况下遍历操作更加方便。

  2. 插入和删除效率高：在双向链表中，插入和删除节点时不需要像单向链表那样需要查找前一个节点，这使得插入和删除操作更加高效。

  3. 便于逆序操作：双向链表可以更方便地进行逆序操作，因为每个节点都有指向前一个节点的指针。

 缺点

  1. 占用更多内存：双向链表中每个节点需要额外的一个指针来指向前一个节点，因此相比单向链表会占用更多的内存空间。

  2. 实现复杂：相比单向链表，双向链表的实现会稍微复杂一些，因为每个节点需要维护两个指针。

  3. 额外的指针开销：双向链表中每个节点都需要额外的指针来指向前一个节点，这意味着在频繁插入和删除节点时，会有更多的指针操作开销。

二、【 双向链表的接口实现】

1. 创建双向链表

  1. 分配内存以存储一个新的ListNode结构体。
  2. 将新节点的prev和next指针都设置为NULL，表示这是一个空的链表头结点。
  3. 返回指向新创建的头结点的指针。
// 创建返回链表的头结点
ListNode* ListCreate() 
{
    // 分配内存以存储一个新的ListNode结构体
    ListNode* head = (ListNode*)malloc(sizeof(ListNode));

    // 将新节点的prev和next指针都设置为NULL，表示这是一个空的链表头结点
    head->prev = NULL;
    head->next = NULL;

    // 返回指向新创建的头结点的指针
    return head;
}

2. 销毁双向链表

  1. 从链表的第一个节点开始，依次释放每个节点的内存。
  2. 为了实现这一点，我们使用一个循环来遍历链表，释放每个节点的内存。
  3. 在循环中，我们首先保存下一个节点的指针，然后释放当前节点的内存，并将下一个节点设置为当前节点，继续释放。
  4. 最后，我们释放头结点的内存，完成整个链表的销毁操作。
// 销毁双向链表
void ListDestroy(ListNode* head) 
{
    ListNode* current = head->next;
    ListNode* next;

    // 从链表的第一个节点开始，依次释放每个节点的内存
    while (current != NULL) 
    {
        next = current->next; // 保存下一个节点的指针
        free(current); // 释放当前节点的内存
        current = next; // 将下一个节点设置为当前节点，继续释放
    }

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

3. 双向链表打印

  1. 从链表的第一个节点开始，依次打印每个节点的数值。
  2. 为了实现这一点，我们使用一个循环来遍历链表，打印每个节点的数值。
  3. 在循环中，我们首先打印当前节点的数值，然后将下一个节点设置为当前节点，继续打印。
  4. 最后，我们在所有节点打印完毕后输出换行符，以便于格式化输出。
// 打印双向链表
void ListPrint(ListNode* head) 
{
    ListNode* current = head->next;

    // 从链表的第一个节点开始，依次打印每个节点的数值
    while (current != NULL) 
    {
        printf("%d ", current->data); // 打印当前节点的数值
        current = current->next; // 将下一个节点设置为当前节点，继续打印
    }
    printf("\n");
}

4. 双向链表尾插

  1. 创建一个新的节点，准备进行尾插操作。
  2. 通过循环找到链表的最后一个节点，以便将新节点插入到末尾。
  3. 设置新节点的数据和指针，使其成为链表中的最后一个节点。
  4. 将新节点链接到链表的末尾，完成尾插操作。
// 双向链表尾插
void ListAppend(ListNode* head, int data) 
{
    ListNode* newNode = (ListNode*)malloc(sizeof(ListNode)); // 创建新节点
    ListNode* current = head;

    // 找到链表的最后一个节点
    while (current->next != NULL) 
    {
        current = current->next;
    }

    // 设置新节点的数据和指针
    newNode->data = data;
    newNode->prev = current;
    newNode->next = NULL;

    // 将新节点链接到链表的末尾
    current->next = newNode;
}

5. 双向链表尾删

  1. 首先进行判断，如果链表为空（即头节点的next指针为空），则无法进行尾删操作，直接返回。
  2. 通过循环找到倒数第二个节点，以便进行尾删操作。
  3. 释放链表中的最后一个节点的内存，并将倒数第二个节点的next指针置为NULL，表示它成为了新的尾部节点。
// 双向链表尾删
void ListRemoveLast(ListNode* head) 
{
    if (head->next == NULL) 
    {
        // 链表为空，无法删除
        return;
    }

    ListNode* current = head;

    // 找到倒数第二个节点
    while (current->next->next != NULL) 
    {
        current = current->next;
    }

    // 释放最后一个节点的内存
    free(current->next);
    current->next = NULL; // 倒数第二个节点的next指针置为NULL，表示它是新的尾部节点
}

6. 双向链表头插

  1. 创建一个新的节点，准备进行头插操作。
  2. 设置新节点的数据和指针，使其成为链表中的第一个节点。
  3. 如果链表不为空，将原先的头节点的prev指针指向新节点。
  4. 更新头节点指针，使其指向新插入的节点，完成头插操作。
// 双向链表头插
void ListInsertFront(ListNode** head, int data) 
{
    ListNode* newNode = (ListNode*)malloc(sizeof(ListNode)); // 创建新节点

    // 设置新节点的数据和指针
    newNode->data = data;
    newNode->prev = NULL;
    newNode->next = *head;

    if (*head != NULL) 
    {
        (*head)->prev = newNode;
    }

    *head = newNode; // 更新头节点指针
}

7. 双向链表头删

  1. 首先进行判断，如果链表为空（即头节点为空），则无法进行头删操作，直接返回。
  2. 保存头节点的地址以便后续释放内存。
  3. 更新头节点指针，使其指向原先头节点的下一个节点。
  4. 如果新的头节点不为空，将其prev指针置为NULL。
  5. 释放原先的头节点内存，完成头删操作。
// 双向链表头删
void ListRemoveFront(ListNode** head) 
{
    if (*head == NULL) 
    {
        // 链表为空，无法删除
        return;
    }

    ListNode* temp = *head; // 保存头节点的地址

    *head = (*head)->next; // 更新头节点指针

    if (*head != NULL) 
    {
        (*head)->prev = NULL; // 更新新的头节点的prev指针为NULL
    }

    free(temp); // 释放原先的头节点内存
}

8. 双向链表查找

  1. 从头节点开始，使用一个指针current来遍历链表。
  2. 在遍历过程中，判断当前节点的数据是否与目标数据匹配，如果匹配则返回当前节点。
  3. 如果当前节点的数据与目标数据不匹配，则将指针current移动到下一个节点，继续遍历。
  4. 如果遍历完整个链表仍未找到匹配的数据，则返回NULL，表示未找到目标数据。
// 双向链表查找
ListNode* ListFind(ListNode* head, int data) 
{
    ListNode* current = head; // 从头节点开始查找

    while (current != NULL) 
    {
        if (current->data == data) 
        {
            // 找到匹配的数据，返回当前节点
            return current;
        }
        current = current->next; // 继续向后遍历
    }

    // 没有找到匹配的数据，返回NULL
    return NULL;
}

9. 双向链表在pos的前面进行插入

  1. 首先进行判断，如果插入位置pos为空，则无法进行插入，直接返回。
  2. 创建一个新的节点newNode，并为其分配内存空间，然后设置新节点的数据为待插入的数据。
  3. 将新节点的prev指针指向pos的前一个节点，这样建立了新节点与pos前面节点的连接。
  4. 如果pos的前一个节点不为空，将其next指针指向新节点；如果pos的前一个节点为空（即pos是头节点），则更新头节点指针为新节点。
  5. 将新节点的next指针指向pos，建立了新节点与pos节点的连接。
  6. 最后，将pos的prev指针指向新节点，完成插入操作。
// 双向链表在指定位置pos的前面进行插入
void ListInsertBefore(ListNode** head, ListNode* pos, int data) 
{
    if (pos == NULL) 
    {
        // 如果插入位置为空，无法插入，直接返回
        return;
    }

    ListNode* newNode = (ListNode*)malloc(sizeof(ListNode)); // 创建新节点
    newNode->data = data; // 设置新节点数据
    newNode->prev = pos->prev; // 新节点的prev指针指向pos的前一个节点

    if (pos->prev != NULL) 
    {
        pos->prev->next = newNode; // pos的前一个节点的next指针指向新节点
    } 
    else 
    {
        *head = newNode; // 如果pos是头节点，则更新头节点指针为新节点
    }

    newNode->next = pos; // 新节点的next指针指向pos
    pos->prev = newNode; // pos的prev指针指向新节点
}

10. 双向链表删除pos位置的结点

  1. 首先进行判断，如果待删除节点pos为空，则无法进行删除操作，直接返回。
  2. 如果pos的前一个节点不为空，将其next指针指向pos的下一个节点，这样跳过了pos节点，将pos节点从链表中移除。
  3. 如果pos的前一个节点为空（即pos是头节点），则更新头节点指针为pos的下一个节点，同时将头节点的prev指针置为NULL。
  4. 如果pos的下一个节点不为空，将其prev指针指向pos的前一个节点，建立了pos节点前后节点的连接。
  5. 最后，释放pos节点的内存空间，完成删除操作。
// 双向链表删除指定位置pos的节点
void ListDelete(ListNode** head, ListNode* pos) 
{
    if (pos == NULL) 
    {
        // 如果待删除节点为空，无法删除，直接返回
        return;
    }

    if (pos->prev != NULL) 
    {
        pos->prev->next = pos->next; // 将pos前一个节点的next指针指向pos的下一个节点
    } 
    else 
    {
        *head = pos->next; // 如果pos是头节点，更新头节点指针为pos的下一个节点
    }

    if (pos->next != NULL) 
    {
        pos->next->prev = pos->prev; // 将pos下一个节点的prev指针指向pos的前一个节点
    }

    free(pos); // 释放pos节点的内存空间
}

三、【完整代码】

#include <stdio.h>
#include <stdlib.h>

// 定义链表节点数据类型
typedef int LTDataType;

// 定义链表节点结构体
typedef struct ListNode 
{
    LTDataType data;         // 节点数据
    struct ListNode* prev;   // 指向前一个节点的指针
    struct ListNode* next;   // 指向下一个节点的指针
} ListNode;

// 创建返回链表的头结点
ListNode* ListCreate() 
{
    ListNode* head = (ListNode*)malloc(sizeof(ListNode));
    head->prev = NULL;
    head->next = NULL;
    return head;
}

// 双向链表销毁
void ListDestory(ListNode* plist) 
{
    ListNode* cur = plist->next;
    while (cur) 
    {
        ListNode* next = cur->next;
        free(cur);
        cur = next;
    }
    free(plist);
}

// 双向链表打印
void ListPrint(ListNode* plist)  
{
    ListNode* cur = plist->next;
    while (cur) 
    {
        printf("%d -> ", cur->data);
        cur = cur->next;
    }
    printf("NULL\n");
}

// 双向链表尾插
void ListPushBack(ListNode* plist, LTDataType x) 
{
    ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
    newNode->data = x;
    newNode->prev = NULL;
    newNode->next = NULL;

    ListNode* tail = plist;
    while (tail->next) 
    {
        tail = tail->next;
    }

    tail->next = newNode;
    newNode->prev = tail;
}

// 双向链表尾删
void ListPopBack(ListNode* plist) 
{
    if (plist->next == NULL) 
    {
        return;
    }

    ListNode* tail = plist;
    while (tail->next) 
    {
        tail = tail->next;
    }

    tail->prev->next = NULL;
    free(tail);
}

// 双向链表头插
void ListPushFront(ListNode* plist, LTDataType x) 
{
    ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
    newNode->data = x;
    newNode->prev = NULL;
    newNode->next = plist->next;

    if (plist->next) 
    {
        plist->next->prev = newNode;
    }

    plist->next = newNode;
}

// 双向链表头删
void ListPopFront(ListNode* plist)   
{
    if (plist->next == NULL) 
    {
        return;
    }

    ListNode* first = plist->next;
    plist->next = first->next;
    if (first->next) 
    {
        first->next->prev = NULL;
    }
    free(first);
}

// 双向链表查找
ListNode* ListFind(ListNode* plist, LTDataType x)  
{
    ListNode* cur = plist->next;
    while (cur) 
    {
        if (cur->data == x) 
        {
            return cur;
        }
        cur = cur->next;
    }
    return NULL;
}

// 双向链表在指定位置pos的前面进行插入
void ListInsertBefore(ListNode** head, ListNode* pos, int data) 
{
    if (pos == NULL) 
    {
        // 如果插入位置为空，无法插入，直接返回
        return;
    }

    ListNode* newNode = (ListNode*)malloc(sizeof(ListNode)); // 创建新节点
    newNode->data = data; // 设置新节点数据
    newNode->prev = pos->prev; // 新节点的prev指针指向pos的前一个节点

    if (pos->prev != NULL) 
    {
        pos->prev->next = newNode; // pos的前一个节点的next指针指向新节点
    } 
    else 
    {
        *head = newNode; // 如果pos是头节点，则更新头节点指针为新节点
    }

    newNode->next = pos; // 新节点的next指针指向pos
    pos->prev = newNode; // pos的prev指针指向新节点
}

// 双向链表删除指定位置pos的节点
void ListDelete(ListNode** head, ListNode* pos) 
{
    if (pos == NULL) 
    {
        // 如果待删除节点为空，无法删除，直接返回
        return;
    }

    if (pos->prev != NULL) 
    {
        pos->prev->next = pos->next; // 将pos前一个节点的next指针指向pos的下一个节点
    } 
    else 
    {
        *head = pos->next; // 如果pos是头节点，更新头节点指针为pos的下一个节点
    }

    if (pos->next != NULL) 
    {
        pos->next->prev = pos->prev; // 将pos下一个节点的prev指针指向pos的前一个节点
    }

    free(pos); // 释放pos节点的内存空间
}

int main() 
{
    // 创建双向链表
    ListNode* head = ListCreate();

    // 尾插数据
    ListPushBack(head, 1);
    ListPushBack(head, 2);
    ListPushBack(head, 3);

    // 打印链表
    printf("双向链表的内容：\n");
    ListPrint(head);

    // 头删数据
    ListPopFront(head);

    // 打印链表
    printf("删除头结点后的双向链表内容：\n");
    ListPrint(head);

    // 销毁链表
    ListDestory(head);

    return 0;
}

猫战士学习中
关注
专栏目录
数据结构：双向链表源码
07-02
双向链表是一种重要的线性数据结构，与单向链表相比，它提供了更灵活的访问和操作方式。本文将深入探讨双向链表的概念、结构以及其源码实现。 双向链表的每个节点不仅包含数据元素，还包含两个指针，一个指向前一个...
数据结构：双向链表的基本程序
07-13
数据结构：双向链表的基本程序
数据结构：双向链表的实现和测试(C++).doc
10-10
数据结构中的双向链表是一种线性数据结构，与单向链表不同，它在每个节点中不仅包含指向下一个节点的指针，还包含一个指向前一个节点的指针。这使得双向链表支持双向遍历，增加了操作的灵活性。本文将深入探讨C++中...
数据结构 双向链表（C++）
06-07
双向链表是一种特殊的数据结构，它在计算机程序设计中扮演着重要角色，特别是在C++这样的编程语言中。本节将深入探讨双向链表的概念、其结构、操作以及C++中的实现。 双向链表与单链表不同，它允许每个节点不仅有一...
数据结构算法——排序算法
qq_73643693的博客
09-07 924
数据结构中的常见算法——排序算法
21_动态规划与数据结构结合
刘炫320的博客
09-11 543
老鸟：假设你有一个数组arr，你需要多次查询某个子数组arr[i:j]的和。直接计算会很慢，我们可以用动态规划预处理，再用一种数据结构来快速查询。菜鸟：听起来不错，但具体怎么做呢？老鸟：我们可以先构建一个数组prefixSum，其中表示数组arr从起始位置到i的和。这样每次查询arr[i:j]的和时，可以用来快速计算。菜鸟：这样确实能减少计算量，但构建prefixSum数组需要什么操作呢？老鸟：好问题。我们来看看代码示例。老鸟：今天我们讨论了动态规划与数据结构结合的应用，通过prefixSum。
数据结构 Java DS——分享部分链表题目 (2)
cjejwe的博客
09-10 959
关于JAVA的链表,笔者已经写了两篇博客来介绍了,今天给笔者们带来第三篇,也是分享了一些笔者写过的,觉得挺好的题目,链接也已经挂上了,笔者们可以去看看。
数据结构之红黑树的 “奥秘“
robin_suli的博客
09-09 1069
红黑树在经常进行增删的结构中性能比 AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。红黑树不追求绝对平衡，其只需保 证最长路径不超过最短路径的2倍(相对平衡)每个结点上增加一个存储位表示结点的颜色。红黑树和AVL树都是高效的平衡二叉树。没有一条路径会比其他路径长出俩倍。先grandParent右旋。围绕红黑树上面的几条性质。
【华为OD】2024D卷——生成哈夫曼树
weixin_45653183的博客
09-12 1306
这是通过构建一种特殊的二叉树来实现的，其中每个字符都位于树的一个叶节点上，且该叶节点到根节点的路径上的边所代表的字符（在哈夫曼编码中通常使用0和1表示）共同构成了该字符的编码。·新节点作为这两个子节点的父节点，而原来的两个节点则成为新节点的左右子节点（通常约定左子节点频率小于等于右子节点）。2、不断从堆中取出两个最小的节点作为左右子树，构造一个新的父节点，其权值为两个节点权值之和，并将新节点插入堆中。·然后，算法反复地选择两个频率最小的节点，将它们合并为一个新的节点，新节点的频率是两个子节点频率之和。
Java-数据结构-二叉树-基础 (oﾟ▽ﾟ)o
2303_80388948的博客
09-12 881
OK，到这里呢，我们的二叉树基础就到这里就结束了，我们接下来看看关于二叉树的相关的习题，并且在题中我们会看见我们 二叉树的创建方法。让我们期待下次的博客吧！！！拜拜啦~~~
[数据结构]二叉搜索树
2302_80220453的博客
09-15 577
今天我们来学习一下新的数据结构，二叉搜索树，这个结构比较简单，是一个铺垫式的结构，为之后的平衡二叉树，AVL树以及红黑树做一个知识基础，我们将从概念到实现具体的介绍二叉搜索树。
【数据结构】线性表的定义和基本操作
m0_74209563的博客
09-12 433
线性表是具有相同数据类型的 n（n≥0）个数据元素的有限序列，其中 n 为表长，当 n=0 时线性表是一个空表注意：① 元素的数据类型相同意味着每个元素所占空间一样大；② 线性表是有限序列意味着各元素之间有先后次序且数量是有限的】若用 L 命名线性表，则其一般表示为La1a2aiai1anLa1​a2​ai​ai1​an​aia_iai​是线性表中的 “第 i 个” 元素线性表中的位序【注意位序是从1开始的，数组下标是从0开始的】a。
从零开始学数据结构系列之第六章《排序简介》
铁匠匠匠的博客
09-12 1040
​所谓排序，就是使一串数据，按照其中的某个或某些关键字的大小，递增或递减排列起来的操作。
数据结构：堆排序
最新发布
2303_78940834的博客
09-15 1005
更完堆，再更一期堆排序。
一天一道算法题day02
m0_74004434的博客
09-06 1797
对于 mm 个数组对 (c[i],b)(c[i],b)，即 (c[1],b),(c[2],b),…,(c[m],b)(c[1],b),(c[2],b),…,(c[m],b) ，根据前面的问题要求，分别计算出它们的答案，最后，你要给出所有答案的总和。注意，数组 c[i]c[i] 是从 aa 数组转化而来的。现在，你需要找到最小的操作次数，使得对于所有的 1≤i≤k1≤i≤k ，都有 ai<biai​<bi​。对于每个测试样例，第一行包含两个整数 n,m，表示数组 a,b的大小，以及元素 a1值的上限。
数据结构——链表
2301_76227083的博客
09-11 907
学习了顺序表就知道，顺序表在大量的头插或者中间插入的时候效率是很低的，需要频繁挪动数据，那么有没有一种数据结构在处理大量头插和中间插入的时候效率非常高呢？是有的，今天我们就来学习一下链表。
【数据结构-一维差分】力扣1893. 检查是否区域内所有整数都被覆盖
sjsjs11的博客
09-12 469
首先因为是差分的办法，所以i开始必须在ranges中最小的range[0]及其左边开始，但是由于可能会出现left在最小range[0]的左边，从而在遍历left到最小range[0]的时候满足了i>left而且s这时候又为0，会返回false。输入：ranges = [[1,2],[3,4],[5,6]], left = 2, right = 5。输入：ranges = [[1,10],[10,20]], left = 21, right = 21。解释：21 没有被任何一个区间覆盖。
嵌入式初学-C语言-数据结构--七
MaBaB的博客
09-12 1034
根指针：指向根节点的指针变量节点：数据域 (存储的实际数据)指针域 (左，右指针)
模拟实现通用型排序
m0_66769266的博客
09-13 596
主要介绍：什么是泛型排序，即：无类型排序，以及库函数qsort()的使用，以及如何自己模拟实现一个泛型的冒泡排序。
数据结构：双向链表前插操作详解
"该资源是一份关于数据结构的课件，特别关注双向链表的前插操作。双向链表是一种数据结构，其中每个节点包含数据和两个指针，分别指向其前一个和后一个节点。前插操作是在指定节点之前插入新节点的算法。提供的代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值