数据结构——双向链表

于 2024-08-28 17:52:30 发布
阅读量771 收藏 7
点赞数 28
分类专栏： 数据结构 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qixi_ao/article/details/141646423
版权

文章目录

双向链表

概念

对链表而言，双向均可遍历是最方便的，另外首尾相连循环遍历也可大大增加链表操作的便捷性。因此，双向循环链表，是在实际运用中是最常见的链表形态。

请添加图片描述

基本操作

与普通的链表完全一致，双向循环链表虽然指针较多，但逻辑是完全一样。基本的操作包括：

  1. 节点设计
  2. 初始化空链表
  3. 增删节点
  4. 链表遍历
  5. 销毁链表

节点设计

双向链表的节点只是比单向链表多了一个前向指针。示例代码如下所示：

typedef int DATA;
typedef struct node
{
    // 以整型数据为例
    DATA data;
    // 指向相邻的节点的双向指针
    struct node *prev;
    struct node *next;
}NODE;

初始化

所谓初始化，就是构建一条不含有效节点的空链表。

以带头结点的双向循环链表为例，初始化后，其状态如下图所示：

请添加图片描述

在初始空链表的情况下，链表只有一个头结点，下面是初始化示例代码：

int dlist_create(NODE** head,DATA data)
{
    // 创建新节点（申请内存空间）
    NODE *pNew = (NODE*)malloc(sizeof(NODE));
    if(!pNew)
    return -1;
    // 给节点赋初值
    pNew -> data = data;
    // 前后指针默认都指向NULL
    pNew -> prev = pNew -> next = NULL;
    // 将新节点作为头节点
    *head = pNew;
    return 0;
}

插入节点

与单链表类似，也可以对双链表中的任意节点进行增删操作，常见的有所谓的头插法、尾插法等，

即：将新节点插入到链表的首部或者尾部，示例代码是：

  • 头插法：新节点插入到链表的头部

    // 将新节点pNew，插入到链表的首部
int dlist_addHead(NODE** head,DATA data)
{
    // 创建新节点并申请内存
    NODE *pNew = (NODE*)malloc(sizeof(NODE));
    if(!pNew)
    return -1;
    // 给新节点赋值
    pNew -> data = data;
    pNew -> prev = NULL;
    // 后针指向头指针
    pNew -> next = *head;
    // 如果头指针存在
    if(*head)
    // 头指针的前指针指向新节点
    (*head) -> prev = pNew;
    // 新插入的节点作为新的头节点
    *head = pNew;
    return 0;
}

  • 尾插法

    // 将新节点pNew，插入到链表的尾部
int dlist_addTail(NODE **head, DATA data)
{
    // 创建节点并申请内存
    NODE *pNew = (NODE *)malloc(sizeof(NODE));
    if (!pNew)
        return -1;
    // 初始化节点
    pNew->data = data;
    pNew->prev = NULL;
    pNew->next = NULL;
    // 用来记录尾节点，默认头节点就是尾节点
    NODE *p = *head;
    if (!p)
    {
        // 头节点不存在，新插入的节点作为头节点
        *head = pNew;
        return 0;
    }
    // 通过循环，查找尾节点
    while (p->next)
    {
        p = p->next;
    }
    // 尾节点的后指针指向新插入的节点
    p->next = pNew;
    // 新插入的节点的前指针指向尾节点
    pNew->prev = p;
    // 此时的新节点作为了新的尾节点
    return 0;
}

  • 中间插法：将新节点插入到链表的指定位置

    // 将新节点pNew，插入到链表的指定位置
int dlist_insert(NODE** head,DATA pos,DATA data)
{
    NODE *pNew = (NODE*)malloc(sizeof(NODE));
    if(!pNew)
        return -1;
    pNew -> data = data;
    pNew -> prev = NULL;
    pNew -> next = NULL;
    NODE* p = *head, *q = NULL;
    if(!p)
    {
        *head = pNew;
        return 0;
    }
    if(memcmp(&(p -> data),&pos,sizeof(DATA)) == 0)
    {
        pNew -> next = p;
        p -> prev = pNew;
        *head = pNew;
        return 0;
    }
    while(p)
    {
        if(memcmp(&(p -> data),&pos,sizeof(DATA)) == 0)
        {
            pNew -> next = p;
            pNew -> prev = q;
            p -> prev = pNew;
            q -> next = pNew;
            return 0;
        }
        q = p;
        p = p -> next;
    }
    q -> next = pNew;
    pNew -> prev = q;
    return 0;
}

剔除节点

 注意，从链表中将一个节点剔除出去，并不意味着要释放节点的内容。当然，我们经常在剔除了一个节点之后，紧接着的动作往往是释放它，但是将“剔除”与“释放”两个动作分开，是最基本的函数封装的原则，因为它们虽然常常连在一起使用，但它们之间并无必然联系，例如：当我们要移动一个节点的时候，实质上就是将“剔除”和“插入”的动作连起来，此时就不能释放该节点了。

在双向链表中剔除指定节点的示例代码如下：

// 将data对应的节点从链表中剔除
int dlist_delete(NODE** head,DATA data)
{
    NODE* p = *head;
    if(!p)
        return -1;
    if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
    {
        if(p -> next == NULL)
        {
            *head = NULL;
            free(p);
            return 0;
        }
        *head = p -> next;
        p -> next -> prev = NULL;
        free(p);
        return 0;
    }
    while(p)
    {
        if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
        {
            p -> prev -> next = p -> next;
            if(p -> next == NULL)
                p -> prev -> next = NULL;
            else
                p -> next -> prev = p -> prev;
            free(p) ;
            return 0;
        }
        p = p -> next;
    }
    return -1;
}

链表的遍历

对于双向循环链表，路径可以是向后遍历，也可以向前遍历。

下面是根据指定数据查找节点，向前、向后遍历的示例代码，假设遍历每个节点并将其整数数据输出：

// 根据指定数据查找节点
NODE* dlist_find(const NODE* head,DATA data)
{
    const NODE* p = head;
    while(p)
    {
        if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
        return (NODE*)p;
        p = p -> next;
    }
    return NULL;
    }
    // 向前|向后遍历
void dlist_showAll(const NODE* head)
    {
    const NODE* p = head;
    while(p)
    {
        printf("%d ",p -> data);
        p = p -> next;// 向后遍历
        // p = p -> prev;// 向前遍历
    }
    printf("\n");
}

修改链表

我们也可以针对链表中的数据进行修改，只需要提供一个修改的源数据和目标数据即可。

示例代码如下：

int dlist_update(const NODE* head,DATA old,DATA newdata)
{
    NODE* pFind = NULL;
    if(pFind = dlist_find(head,old))
    {
        pFind -> data = newdata;
        return 0;
    }
    return -1;
}

销毁链表

由于链表中的各个节点被离散地分布在各个随机的内存空间，因此销毁链表必须遍历每一个节点，释放每一个节点。

注意：

销毁链表时，遍历节点要注意不能弄丢相邻节点的指针

示例代码如下：

void dlist_destroy(NODE** head)
{
    NODE *p = *head, *q = NULL;
    while(p)
    {
        q = p;
        p = p -> next;
        free(q);
    }
    *head = NULL;
}

完整案例

  • dlist.h

    #ifndef __DLIST_H
#define __DLIST_H
typedef int DATA;
typedef struct node
{
    DATA data;
    struct node *prev;// 前驱指针
    struct node *next;// 后继指针
}NODE;
// 创建链表（初始化）
int dlist_create(NODE**,DATA);
// 向链表插入数据（头插法）
int dlist_addHead(NODE** head,DATA data);
// 向链表插入数据（尾插法）
int dlist_addTail(NODE** head,DATA data);
// 向链表插入数据（中间插法）
int dlist_insert(NODE** head,DATA pos,DATA data);
// 链表数据查询
NODE* dlist_find(const NODE* head,DATA data);
// 链表数据更新
int dlist_update(const NODE* head,DATA old,DATA newdata);
// 链表数据遍历
void dlist_showAll(const NODE* head);
// 链表数据删除
int dlist_delete(NODE** head,DATA data);
// 链表回收
void dlist_destroy(NODE** head);
#endif

  • dlist.c

    #include "dlist.h"

/**
 * @function:   int dlist_create(NODE**,DATA);
 * @berif:      创建双向链表
 * @argument:   head: 指向头指针变量的地址，用来接收首节点地址
 *              data: 存储在节点中的数据
 * @return :    成功返回 0
 *              失败返回 -1
 */
int dlist_create(NODE **head, DATA data)
{
    // 创建一个节点（申请内存）
    NODE *pNew = (NODE *)malloc(sizeof(NODE));
    if (!pNew)
    {
        perror("内存申请失败！");
        return -1;
    }

    // 节点的初始化
    pNew->data = data;
    pNew->prev = pNew->next = NULL; // 给前驱指针和后继指针都赋值为NULL

    // 将pNew作为头结点
    *head = pNew;
    return 0;
}

/**
 * @function:   int dlist_addHead(NODE**,DATA);
 * @berif:      向链表头部插入数据
 * @argument:   head: 指向头指针变量的地址，用来接收首节点地址
 *              data: 存储在节点中的数据
 * @return :    成功返回 0
 *              失败返回 -1
 */
int dlist_addHead(NODE **head, DATA data)
{
    // 创建一个节点，申请内存
    NODE *pNew = (NODE *)malloc(sizeof(NODE));
    // 校验
    if (!pNew)
    {
        perror("内存申请失败！");
        return -1;
    }
    // 给节点赋值
    pNew->data = data;
    pNew->prev = NULL;
    pNew->next = *head;

    // 如果头结点存在，需要设置head.prev指向pNew
    if (*head)
    {
        (*head)->prev = pNew;
    }
    // 将pNew作为新的头结点
    *head = pNew;

    return 0;
}

/**
 * @function:   int dlist_addTail(NODE**,DATA);
 * @berif:      向链表尾部插入数据
 * @argument:   head: 指向头指针变量的地址，用来接收首节点地址
 *              data: 存储在节点中的数据
 * @return :    成功返回 0
 *              失败返回 -1
 */
int dlist_addTail(NODE **head, DATA data)
{
    // 创建一个节点，申请内存
    NODE *pNew = (NODE *)malloc(sizeof(NODE));
    if (!pNew)
    {
        perror("内存申请失败！");
        return -1;
    }

    // 给节点赋初值
    pNew->data = data;
    pNew->prev = pNew->next = NULL;

    // 定义一个变量，用来存储尾结点
    NODE *p = *head;

    // 第一种情况：没有节点，pNew作为头结点
    if (!p)
    {
        *head = pNew;
        return 0;
    }

    // 第二种情况：有节点，向末尾添加pNew
    while (p->next)
    {
        // 移动p的位置
        p = p->next;
    }

    // 末尾的p节点跟pNew建立联系，此时pNew称为尾结点
    p->next = pNew;
    pNew->prev = p;

    return 0;
}

/**
 * @function:   int dlist_insert(NODE**,DATA,DATA);
 * @berif:      向链表任意位置插入数据（中间插法）
 * @argument:   head: 指向头指针变量的地址，用来接收首节点地址
 *              pos：目标位置数据
 *              data: 存储在节点中的数据
 * @return :    成功返回 0
 *              失败返回 -1
 */
int dlist_insert(NODE **head, DATA pos, DATA data)
{
    // 创建节点，申请内存
    NODE *pNew = (NODE *)malloc(sizeof(NODE));
    if (!pNew)
    {
        perror("内存申请失败！");
        return -1;
    }

    // 给节点赋初值
    pNew->data = data;
    pNew->prev = pNew->next = NULL;

    NODE *p = *head, *q = NULL;

    // 第一种情况：没有节点，pNew作为头结点
    if (!p)
    {
        *head = pNew;
        return 0;
    }

    // 第二种情况：pos对应的节点刚好是头结点（有效节点是头结点，只有一个节点的时候）
    if (memcmp(&(p->data), &pos, sizeof(DATA)) == 0)
    {
        pNew->next = p;
        p->prev = pNew;
        *head = pNew;
        return 0;
    }
    // 第三种情况：pos对应的节点不是头结点（有效节点超过两个）
    while (p) // p 判断当前节点是否为NULL，p->next 判断写一个节点是否为NULL
    {
        if (memcmp(&(p->data), &pos, sizeof(DATA)) == 0)
        {
            pNew->next = p;
            pNew->prev = q;
            p->prev = pNew;
            q->next = pNew;
            return 0;
        }
        // 记录当前位置（上一个节点的位置）
        q = p;
        // 记录下一个节点的位置，也就是更新后的p
        p = p->next;
    }
    // 如果在链表中找不到pos对应的节点，就尾插
    q->next = pNew;
    pNew->prev = q;

    return 0;
}

/**
 * @function:   void dlist_showAll(const NODE*);
 * @berif:      向链表任意位置插入数据（中间插法）
 * @argument:   head: 指向头指针变量的地址，用来接收首节点地址
 *              pos：目标位置数据
 *              data: 存储在节点中的数据
 * @return :    成功返回 0
 *              失败返回 -1
 */
void dlist_showAll(const NODE *head)
{
    const NODE *p = head;
    while (p)
    {
        printf("%d ", p->data);
        // 向后遍历
        p = p->next;
        // 向前遍历
        // p = p->prev;
    }
    printf("\n");
}

/**
 * @function:   NODE* dlist_find(const NODE*,DATA);
 * @berif:      链表数据查询（根据指定的数据查找节点）
 * @argument:   head: 指向头指针变量的地址，用来接收首节点地址
 *              data: 要检索的数据
 * @return :    成功返回 NODE*
 *              失败返回 NULL
 */
NODE *dlist_find(const NODE *head, DATA data)
{
    // 创建一个变量去接收链表
    const NODE *p = head;

    while (p)
    {
        if (memcmp(&(p->data), &data, sizeof(DATA)) == 0)
        {
            return (NODE *)p;
        }

        p = p->next;
    }
    return NULL;
}

//
/**
 * @function:   dlist_update(const NODE*,DATA,DATA);
 * @berif:      链表数据更新
 * @argument:   head: 指向头指针变量的地址，用来接收首节点地址
 *              old_data：源数据
 *              new_data: 目标数据
 * @return :    成功返回 0
 *              失败返回 -1
 */
int dlist_update(const NODE *head, DATA old_data, DATA new_data)
{
    // 用来接收查询到的节点
    NODE *pFind = NULL;

    // 利用刚刚写的查询函数，查询
    if (!(pFind = dlist_find(head, old_data)))
    {
        return -1;
    }
    // 更新数据
    pFind->data = new_data;

    return 0;
}

/**
 * @function:   dlist_delete(NODE**,DATA);
 * @berif:      链表数据删除
 * @argument:   head: 指向头指针变量的地址，用来接收首节点地址
 *              data: 需要删除的数据
 * @return :    成功返回 0
 *              失败返回 -1
 */
int dlist_delete(NODE **head, DATA data)
{
    // 记录需要删除的节点的位置
    NODE *p = *head;

    // 第一种情况：链表不存在
    if (!p)
    {
        return -1;
    }
    // 第二种情况：删除的数据对应的节点正好是头结点
    if (memcmp(&(p->data), &data, sizeof(DATA)) == 0)
    {
        // 1. 链表中只有一个节点
        if (p->next == NULL)
        {
            free(p);
            *head = NULL;
            return 0;
        }
        // 2. 链表中有两个以上节点
        // 执行下列代码之前，head和p都指向头结点，下面代码的意思是：将p节点的下一个节点作为新的头结点
        *head = p->next;
        // 解除p的引用关系(下一个节点指向它的关系)
        p->next->prev = NULL;
        // 回收p
        free(p);

        return 0;
    }

    // 正常删除：链表中要删除的节点不是头结点
    while (p)
    {
        if (memcmp(&(p->data), &data, sizeof(DATA)) == 0)
        {
            // p的上一个节点的next指向p的下一个节点
            p->prev->next = p->next;
            
            // p是尾结点
            if(p->next==NULL)
            {
                // 解除p的上一个节点跟p的引用
                p->prev->next = NULL;
            }
            else // p不是尾结点
            {
                // p的下一个节点的prev指向p的上一个节点
                p->next->prev = p->prev;
            }
            // 回收解除引用的节点
            free(p);
            return 0;
        }

        // 改变循环条件
        p = p->next;
    }

    return -1;
}

/**
 * @function:   void dlist_destroy(NODE**);
 * @berif:      链表回收
 * @argument:   head: 指向头指针变量的地址，用来接收首节点地址
 *              old_data：源数据
 *              new_data: 目标数据
 * @return :    成功返回 0
 *              失败返回 -1
 */
void dlist_destroy(NODE **head)
{
    // p记录移动的节点，q记录需要回收的节点
    NODE *p = *head, *q = NULL;

    while (p)
    {
        // 实现指针尾随
        q = p;       // 前一个节点
        p = p->next; // 后一个节点
        // 回收q
        free(q);
    }
    *head = NULL;
}

适用场合

经过单链表、双链表的学习，可以总结链表的适用场合：

  • 适合用于节点数目不固定，动态变化较大的场合
  • 适合用于节点需要频繁插入、删除的场合
  • 适合用于对节点查找效率不十分敏感的场合
qixi_ao
关注
  • 28
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
redis的数据结构——双向链表
jkzyx123的博客
08-20 881
Redis的双向链表数据结构详解
数据结构——双向链表（保姆级教程，包学包会）
m0_74459304的博客
05-14 8126
1.双向链表的概念 双向链表就是带头双向循环链表 我们在学完单链表之后，就感觉这个非常简单了，他的主要表现就是拥有头节点，链表永不为空，不需要二级指针；可以通过一个节点找到上一个或者下一个节点；头尾相连呈环状。 他主要结构是由prev、next、data，这三个结构组成，通过prev找到前一个节点，next就不用多说了。
数据结构 —— 双向链表（超详细图解 & 接口函数实现）
十里坡小白的博客
08-08 6738
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。博主将会用代码结合大量图解，对数据结构进行深度剖析。
数据结构——双向链表及其总结
2406_83392683的博客
07-23 522
1.概述链表根据是否带头、是否双向、是否循环可以分为八种，双向链表是典型的带头双向循环链表。2.双向链表的实现过程及其解析双向链表的实现依旧包含List.h，List.c，test.c2.1 链表初始化双向链表为空的情况：只有一个哨兵位。2.2插入数据。
数据结构基础——双向链表
XXXTENTAC1ON的博客
04-11 535
双向链表什么是双向链表双向链表的实现1、结构的声明2、方法的声明3、方法的实现 什么是双向链表 首先，双向链表一样是链表，逻辑上存储连续，物理上存储不连续。但是相对于单链表每个结点存储两个数据（data 数据 next 下一个结点的地址），双向链表每个结点存储三个数据，比普通链表多 prior 储存上一结点的地址。 双向链表的每个结点除了存储后一个结点的地址，还需要存储前一个结点的地址。 – 从前向后遍历和从后向前遍历 双向链表的实现 1、结构的声明 typedef double DataType
数据结构——双向链表PTA习题
流楚丶格念的博客
12-17 5922
文章目录单选题函数题6-1 链式表操作集 (20分)各个操作函数的定义为：输入样例：输出样例：代码6-2 带头结点的链式表操作集 (20分)输入样例：输出样例：代码6-4 共享后缀的链表 (25分)输入样例：输出样例：代码 单选题 题号 题目 答案 1 设h为不带头结点的单向链表。在h的头上插入一个新结点t的语句是： t->next=h; h=t; 2 带头结点的单链表h为空的判定条件是： h->next == NULL; 3 对于一非空的循环单链表，h和p分别
JavaScript 数据结构 ==== 二叉树
每天都要努力学习哦~~
08-24 1003
二叉树中的节点最多只能有2个子节点，一个是左侧子节点，一个是右侧子节点，这样定义的好处是有利于我们写出更高效的插入，查找，删除节点的算法。二叉搜索树是二叉树的一种，但是它只允许你在左侧子节点存储比父节点小的值，但在右侧节点存储比父节点大的值。接下来我们将按照这个思路去实现一个二叉搜索树。
数据结构——树的三种表示方法
2301_80401288的博客
08-24 1180
数据结构——树的三种表示方法 求点赞收藏关注！！！
数据结构之链表
WSH2012ffff的博客
08-27 226
本文从链表的定义、创建、遍历、插入、删除等多个方面进行了详细讲解，希望能够帮助大家更好地理解和掌握c/c++语言中的链表操作。链表是一种动态数据结构，由节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。链表是计算机科学中常见的一种数据结构，c/c++语言中也有着丰富的链表操作函数库。在c/c++中，可以使用结构体来定义一个节点，并用指针来表示节点之间的关系，从而实现链表。链表遍历是指按照一定的顺序依次访问链表中的每一个节点。链表删除是指在链表中删除一个节点。
【高阶数据结构】——并查集：高效地管理集合
2301_80220607的博客
08-27 416
【高阶数据结构】并查集：学习高效的管理数据，学会用图来解释数据关系
数据结构（邓俊辉）学习笔记】优先级队列 08——左式堆：结构
weixin_44399845的博客
08-23 1057
学习左式堆的结构
Java-数据结构-包装类和认识泛型 !!!∑(ﾟДﾟノ)ノ
最新发布
2303_80388948的博客
08-27 607
对于泛型就是：使用与许多许多类型。从代码上来说呢，就是对类型实现了参数化。对于引出泛型，我们来实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值。在这里呢，我们用 Object类 来进行创建数组，Object是所有类的父类，但是呢，我们在这里呢就有一些问题，我们来看看：1、在这里呢，我们这个数组当中可以存放任何类型2、我们每次进行的到值时候呢，都要进行强转。
数据结构—链表
2301_79909332的博客
08-27 457
数据量增长与程序运行时间的比例关系以函数描述称为时间渐进复杂度函数,简称时间复杂度。数据量增长与程序所占用空间的比例关系称为空间复杂度。顺序表、链式表、顺序栈、链式栈、顺序队列、链式队列 、树 二叉树。使用该函数遍历顺序表内元素，符合条件的可对其进行计数和打印。使用该函数遍历顺序表内元素，符合条件的对其进行修改。3.链表空间不连续,使得理论上长度是无限的。2.链表需要更大的空间存放数据和节点地址。1.空间可以不连续，访问元素不方便。3.程序 = 数据结构 + 算法。4.链表的插入和删除效率很高。
C学习（数据结构）--＞实现链式结构二叉树
weixin_47298551的博客
08-22 1030
遍历完 6 结点，再次返回 2 结点，此时 2 结点的左右孩子结点都遍历完，所以返回 1 结点，此时 1 结点的左孩子结点已经遍历完成，则遍历1 结点的右孩子结点，即 3 结点。与层序遍历类似，不同的是，取消了判断左右孩子结点是否为空结点，所以就算左右孩子结点为空值结点也会入队列，所以不完全二叉树会出现这种情况。此时4结点已经遍历完，放回 2 结点，因为 4 结点是 2 结点的左孩子结点，开始遍历 2 结点的右孩子结点，即标号为 6 的结点。标号为 2 的结点作为新的根结点，遍历 2 结点，且打印。
集合及数据结构第九节————树和二叉树
2301_79418684的博客
08-23 1141
树和二叉树 1. 树型结构的概念 2. 树的概念 3. 树的表示形式（了解） 4. 树的应用 5. 二叉树的概念 6. 两种特殊的二叉树 7. 二叉树的性质 8. 二叉树的性质练习 9. 二叉树的存储 10. 二叉树的遍历 11. 二叉树的基本操作 12. 二叉树相关练习题
《数据结构（C语言版）第二版》第七章-查找（7.2-7.3.1）
qq_44883214的博客
08-25 234
一个无序序列可以通过构造一棵二叉排序树而变成一个有序序列， 构造树的过程即为对无序序列进行排序的过程。无论输入时的序列是何种顺序，CreatBST函数都会返回一个符合二叉排序树定义的正确的二叉排序树。
【数据结构入门】二叉树之堆的实现
KevinRay_0854的博客
08-20 1530
堆是一种重要的数据结构，常用于解决各种问题，如优先队列、排序算法、图算法等。堆具有很多特性，其中最常见的是最大堆和最小堆。最大堆中，每个节点的值都大于等于其子节点的值，而最小堆则相反，每个节点的值都小于等于其子节点的值。在本文中，我们将详细介绍堆的概念、性质和操作。我们将以一个具体的例子来说明堆的构建和调整过程，并通过图示展示堆的结构。最后，我们还将讨论堆在实际应用中的一些常见用途和算法。通过学习堆，您将能够更好地理解和应用这一重要的数据结构。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值