数据结构与算法⑪(第四章_中)堆的分步构建

已于 2023-04-26 12:58:21 修改
阅读量395 收藏 2
点赞数 3
分类专栏： ③数据结构与算法（C语言描述） 文章标签： c语言 数据结构 算法 Powered by 金山文档
于 2023-02-23 20:34:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GRrtx/article/details/129171604
版权

不清楚堆的概念和性质公式可以先到上一篇看看

链接：数据结构与算法⑩(第四章_上)树和二叉树和堆的概念及结构_GR C的博客-CSDN博客

【百度百科】堆（Heap）是计算机科学中一类特殊的数据结构的统称。
堆通常是一个可以被看做 一棵完全二叉树的数组对象。

完全二叉树的性质就是堆的性质，堆是完全二叉树的顺序结构存储。

① 堆总是一棵完全二叉树。

② 堆中的某个节点的值总是不大于或不小于其父节点的值。

堆的逻辑结构是完全二叉树，物理（存储）结构是数组

1.完整Heap.h

和以前学的数据结构一样，先定义出堆的结构体，然后实现接口函数。

先给出Heap.h的代码：

#pragma once

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

typedef int HPDataType;

typedef struct Heap 
{
    HPDataType* array;  //指向动态开辟的数组
    int size;           //有效数据的个数
    int capacity;       //容量空间的大小
} Heap;

void HeapInit(Heap* php);//初始化堆
void HeapDestroy(Heap* php);//堆的销毁
void HeapPrint(Heap* php);//堆的打印
bool HeapEmpty(Heap* php);//判断堆是否为空
HPDataType HeapTop(Heap* php);//返回堆顶数据
int HeapSize(Heap* php);//统计堆的个数
void HeapCheckCapacity(Heap* php);//检查容量
void Swap(HPDataType* px, HPDataType* py);//交换函数

void HeapPush(Heap* php, HPDataType x);//堆的插入

void BigAdjustUp(int* arr, int child);//大根堆上调

void SmallAdjustUp(int* arr, int child);//小根堆上调

void HeapPop(Heap* php);//堆的删除

void SmallAdjustDown(int* arr, int n, int parent);//小根堆下调

void BigAdjustDown(int* arr, int n, int parent);//大根堆下调

2.八个简单函数

这八个函数前几篇数据结构文章都讲过类似的了，直接放出来

void HeapInit(Heap* php)//初始化堆
{
    assert(php);
    php->array = NULL;
    php->size = php->capacity = 0;
}

void HeapDestroy(Heap* php) //堆的销毁
{
    assert(php);
    free(php->array);
    php->capacity = php->size = 0;
}

void HeapPrint(Heap* php) //堆的打印
{
    for (int i = 0; i < php->size; i++) 
    {
        printf("%d ", php->array[i]);
    }
    printf("\n");
}

bool HeapEmpty(Heap* php)//判断堆是否为空
{
    assert(php);

    return php->size == 0; // 如果为size为0则表示堆为空
}

HPDataType HeapTop(Heap* php) //返回堆顶数据
{
    assert(php);
    assert(!HeapEmpty(php));

    return php->array[0];
}

int HeapSize(Heap* php) //统计堆的个数
{
    assert(php);

    return php->size;
}

void HeapCheckCapacity(Heap* php) //检查容量 写过很多次了
{
    if (php->size == php->capacity) 
    {
        int newCapacity = php->capacity == 0 ? 4 : (php->capacity * 2); 
   HPDataType* tmpArray = (HPDataType*)realloc(php->array, sizeof(HPDataType) * newCapacity);
        if (tmpArray == NULL)
        {  
            printf("realloc failed!\n");
            exit(-1);
        }
        //更新他们的大小
        php->array = tmpArray;
        php->capacity = newCapacity;
    }
}

void Swap(HPDataType* px, HPDataType* py) //交换函数
{
    HPDataType tmp = *px;
    *px = *py;
    *py = tmp;
}

3.大堆的插入（HeapPush）

void HeapPush(HP* php, HPDataType x) 
{
    assert(php);  
    // 写到这里写一个检查是否需要增容
    HeapCheckCapacity(php);
    // 插入数据
    php->array[php->size] = x;
    php->size++;
    // 写到这里写一个向上调整 传入目标数组，和插入的数据（即 size - 1）。
    AdjustUp(php->array, php->size - 1); 
}

插入的核心思路：

① 先将元素插入到堆的末尾，即最后一个孩子之后。

② 插入之后如果堆的性质遭到破坏，就将新插入的节点顺着其的父亲往上调整到合适位置。

直到调到符合堆的性质为止。

根据堆的性质，如果不满足大堆和小堆，出现子大于父或父大于子的情况，

为了保证插入之后堆还是堆，我们就需要进行自下往上的调整。

堆插入数据对其他节点没有影响，只是可能会影响从它到根节点路径上节点的关系。

比如下面的情况：新插入的为 60，子大于父（60 > 56 ），这时就需要交换。

先把父亲赋值给孩子，再把孩子赋值给父亲，再让父亲往上走，判断是否比父亲大，如果大就再进行交换。 为了搞定这些情况，我们就需要写一个 "向上调整" 的算法（最坏调到根停止）：

3.1大堆向上调整（BigAdjustUp）

void BigAdjustUp(int* arr, int child) //大根堆上调
{
    assert(arr);
    // 首先根据公式计算算出父亲的下标
    int parent = (child - 1) / 2;
    // 最坏情况:调到根，child=parent 当child为根节点时结束（根节点永远是0）
    while (child > 0) //不能写parent >= 0
    {                 //为什么呢？最后一次往上走时，
                     //child = parent;  此时child = 0
                     //parent = (child - 1) / 2;
                     //(0 - 1) / 2 = 0  这么一来parent仍然会是0
                     //导致parent根本就不会小于0
        if (arr[child] > arr[parent]) // 如果孩子大于父亲（不符合堆的性质）
        {  
            // 交换他们的值
            Swap(&arr[child], &arr[parent]);
            // 往上走
            child = parent;
            parent = (child - 1) / 2;
        }
        else// 如果孩子小于父亲（符合堆的性质）
        {  
            break;// 跳出循环
        }
    }
}

3.2小堆向上调整（SmallAdjustUp）

如果我们想改成小堆向上调整呢？

只需要改变一下大于小于判断条件即可：

void SmallAdjustUp(int* arr, int child) //小堆上调
{
    assert(arr);
    // 首先根据公式计算算出父亲的下标
    int parent = (child - 1) / 2;
    // 最坏情况:调到根，child=parent 当child为根节点时结束（根节点永远是0）
    while (child > 0)
    {
        if (arr[child] < arr[parent])  // 如果孩子小于父亲（不符合小堆的性质）
        { 
            Swap(&arr[child], &arr[parent]);
            // 往上走
            child = parent;
            parent = (child - 1) / 2;
        }
        else  // 如果孩子小于父亲（符合堆的性质）
        {  
            break;
        }
    }
}

4.堆的删除（HeapPop）

因为在讲堆的插入时我们用大堆演示的，我们这里先用小堆来演示。

删除的核心思路：删除堆，删除的是堆顶的数据。就是删除这个树的根。

如果直接挪动数据把堆顶数据覆盖，那么堆的结构就乱了，还要走一遍插入的逻辑，效率太低

所以有人想出一种很巧妙的方法：

将堆顶的数据跟最后一个数据一换，然后删除数组最后一个数据，再进行向下调整算法。

（向下调整算法堆排序要使用，使用前提是左子树和右子树都是大堆/小堆）

① 将堆顶元素与堆中最后一个元素进行交换。

② 删除堆中的最后一个元素。

③ 将堆顶元素向下调整到满足堆特性为止。

void HeapPop(HP* php)
 {
    assert(php);
    assert(!HeapIsEmpty(php));
    // 删除数据
    Swap(&php->array[0], &php->array[php->size - 1]);
    php->size--;
    // 写到这里写一个向下调整 传入目标数组，，数组的大小，调整位置的起始位置
    SmalljustDown(php->array, php->size, 0);
}

4.1小堆向下调整（SmallAdjustDown）

向下调整，把它调整成堆，跟左右孩子中小的那个交换。

结束条件（有一个成立即可）：

① 父<=小的孩子，则停止。

② 调整到叶子（因为叶子特征为没有孩子，左孩子下标超出数组范围，就不存在了）。

//小根堆下调 左右子树为小根堆，根节点不满足时使用  左右子树不满足就对其进行下调
void SmallAdjustDown(int* arr, int n, int parent) 
{
    int child = parent * 2 + 1; // 默认为左孩子
    while (child < n) // 叶子内
    { 
        // 选出左右孩子中小的那一个
        if (child + 1 < n && arr[child + 1] < arr[child]) //左孩子+1为右孩子
        {    //如果 child + 1 比 n 大，就说明没有右孩子，默认是对的
            child++;//左孩子+1更新为右孩子
        }
        if (arr[child] < arr[parent])// 如果孩子小于父亲（不符合小堆的性质）
        { 
            // 交换它们的值
            Swap(&arr[child], &arr[parent]);
            // 往下走
            parent = child;
            child = parent * 2 + 1;
        }
        else // 如果孩子大于父亲（符合小堆的性质）
        { 
            break;
        }
    }
}

如果我们想改成大堆呢？

也只需要改变一下大于小于判断条件即可：

① 选出左右孩子大的那一个。

② 小堆是所有父亲都小于孩子，大堆则是所有父亲都要大于孩子，我们来改一下：

4.2大堆向下调整（BigAdjustDown）

void BigAdjustDown(int* arr, int n, int parent) //大堆下调
{
    int child = parent * 2 + 1; // 默认为左孩子
    while (child < n) { // 叶子内
        // 选出左右孩子中大的那一个
        if (child + 1 < n && arr[child + 1] > arr[child]) 
        {
            child++;
        }
        if (arr[child] > arr[parent]) // 如果孩子大于父亲（不符合大堆的性质）
        {
            // 交换它们的值
            Swap(&arr[child], &arr[parent]);
            // 往下走
            parent = child;
            child = parent * 2 + 1;
        }
        else  // 如果孩子小于父亲（符合大堆的性质）
        {
            break;
        }
    }
}

5.堆的构建完整代码

Heap.h

#pragma once

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

typedef int HPDataType;

typedef struct Heap 
{
    HPDataType* array;  //指向动态开辟的数组
    int size;           //有效数据的个数
    int capacity;       //容量空间的大小
} Heap;

void HeapInit(Heap* php);//初始化堆
void HeapDestroy(Heap* php);//堆的销毁
void HeapPrint(Heap* php);//堆的打印
bool HeapEmpty(Heap* php);//判断堆是否为空
HPDataType HeapTop(Heap* php);//返回堆顶数据
int HeapSize(Heap* php);//统计堆的个数
void HeapCheckCapacity(Heap* php);//检查容量
void Swap(HPDataType* px, HPDataType* py);//交换函数

void HeapPush(Heap* php, HPDataType x);//堆的插入

void BigAdjustUp(int* arr, int child);//大根堆上调

void SmallAdjustUp(int* arr, int child);//小根堆上调

void HeapPop(Heap* php);//堆的删除

void SmallAdjustDown(int* arr, int n, int parent);//小根堆下调

void BigAdjustDown(int* arr, int n, int parent);//大根堆下调

Heap.c

#define _CRT_SECURE_NO_WARNINGS 1

#include "Heap.h"

void HeapInit(Heap* php)//初始化堆
{
    assert(php);
    php->array = NULL;
    php->size = php->capacity = 0;
}

void HeapDestroy(Heap* php) //堆的销毁
{
    assert(php);
    free(php->array);
    php->capacity = php->size = 0;
}

void HeapPrint(Heap* php) //堆的打印
{
    for (int i = 0; i < php->size; i++) 
    {
        printf("%d ", php->array[i]);
    }
    printf("\n");
}

bool HeapEmpty(Heap* php)//判断堆是否为空
{
    assert(php);

    return php->size == 0; // 如果为size为0则表示堆为空
}


HPDataType HeapTop(Heap* php) //返回堆顶数据
{
    assert(php);
    assert(!HeapEmpty(php));

    return php->array[0];
}

int HeapSize(Heap* php) //统计堆的个数
{
    assert(php);

    return php->size;
}

void HeapCheckCapacity(Heap* php) //检查容量  写过很多次了
{
    if (php->size == php->capacity) 
    {
        int newCapacity = php->capacity == 0 ? 4 : (php->capacity * 2); //第一次给4，其他情况扩2倍
        HPDataType* tmpArray = (HPDataType*)realloc(php->array, sizeof(HPDataType) * newCapacity); // 数组扩容
        if (tmpArray == NULL)
        {  //检查realloc
            printf("realloc failed!\n");
            exit(-1);
        }
        //更新他们的大小
        php->array = tmpArray;
        php->capacity = newCapacity;
    }
}

void Swap(HPDataType* px, HPDataType* py) //交换函数
{
    HPDataType tmp = *px;
    *px = *py;
    *py = tmp;
}

void BigAdjustUp(int* arr, int child) //大根堆上调
{
    assert(arr);
    // 首先根据公式计算算出父亲的下标
    int parent = (child - 1) / 2;
    // 最坏情况:调到根，child=parent 当child为根节点时结束（根节点永远是0）
    while (child > 0) //不能写parent >= 0
    {                 //为什么呢？最后一次往上走时，
                     //child = parent;  此时child = 0
                     //parent = (child - 1) / 2;
                     //(0 - 1) / 2 = 0  这么一来parent仍然会是0
                     //导致parent根本就不会小于0
        if (arr[child] > arr[parent]) // 如果孩子大于父亲（不符合大堆的性质）
        {  
            // 交换他们的值
            Swap(&arr[child], &arr[parent]);
            // 往上走
            child = parent;
            parent = (child - 1) / 2;
        }
        else// 如果孩子小于父亲（符合堆的性质）
        {  
            break;// 跳出循环
        }
    }
}

void SmallAdjustUp(int* arr, int child) //小堆上调
{
    assert(arr);
    // 首先根据公式计算算出父亲的下标
    int parent = (child - 1) / 2;
    // 最坏情况:调到根，child=parent 当child为根节点时结束（根节点永远是0）
    while (child > 0)
    {
        if (arr[child] < arr[parent])  // 如果孩子小于父亲（不符合小堆的性质）
        { 
            Swap(&arr[child], &arr[parent]);
            // 往上走
            child = parent;
            parent = (child - 1) / 2;
        }
        else  // 如果孩子小于父亲（符合堆的性质）
        {  
            break;
        }
    }
}

void HeapPush(Heap* php, HPDataType x) 
{
    assert(php);
    // 检查是否需要扩容
    HeapCheckCapacity(php);
    // 插入数据
    php->array[php->size] = x;
    php->size++;
    // 向上调整 [目标数组，调整位置的起始位置（刚插入的数据）]
    BigAdjustUp(php->array, php->size - 1);
}


//小根堆下调  左右子树为小根堆，根节点不满足时使用  左右子树不满足就对其进行下调
void SmallAdjustDown(int* arr, int n, int parent) 
{
    int child = parent * 2 + 1; // 默认为左孩子
    while (child < n) // 叶子内
    { 
        // 选出左右孩子中小的那一个
        if (child + 1 < n && arr[child + 1] < arr[child]) //左孩子+1为右孩子
        {    //如果 child + 1 比 n 大，就说明没有右孩子，默认是对的
            child++;//左孩子+1更新为右孩子
        }
        if (arr[child] < arr[parent])// 如果孩子小于父亲（不符合小堆的性质）
        { 
            // 交换它们的值
            Swap(&arr[child], &arr[parent]);
            // 往下走
            parent = child;
            child = parent * 2 + 1;
        }
        else // 如果孩子大于父亲（符合小堆的性质）
        { 
            break;
        }
    }
}

void BigAdjustDown(int* arr, int n, int parent) //大根堆下调
{
    int child = parent * 2 + 1; // 默认为左孩子
    while (child < n) // 叶子内
    { 
        // 选出左右孩子中大的那一个
        if (child + 1 < n && arr[child + 1] > arr[child]) 
        {
            child++;
        }
        if (arr[child] > arr[parent]) { // 如果孩子大于父亲（不符合大堆的性质）
            // 交换它们的值
            Swap(&arr[child], &arr[parent]);
            // 往下走
            parent = child;
            child = parent * 2 + 1;
        }
        else  // 如果孩子小于父亲（符合大堆的性质）
        {
            break;
        }
    }
}

void HeapPop(Heap* php) 
{
    assert(php);
    assert(!HeapEmpty(php));
    // 删除数据
    Swap(&php->array[0], &php->array[php->size - 1]);
    php->size--;
    // 向下调整 [目标数组，数组的大小，调整位置的起始位置]
    //SmallAdjustDown(php->array, php->size, 0);
    BigAdjustDown(php->array, php->size, 0);
}

Test.c

#include"Heap.h"

int main()
{
    Heap h;
    HeapInit(&h);
    int arr[] = { 15,18,19,25,34,28,65,27,49,37 };
    for (int i = 0;i < sizeof(arr) / sizeof(arr[0]);i++)
    {
        HeapPush(&h, arr[i]);
    }
    HeapPrint(&h);

    HeapPop(&h);
    HeapPrint(&h);

    HeapPush(&h, 100);
    HeapPush(&h, 40);
    HeapPrint(&h);
    HeapPop(&h);
    HeapPrint(&h);

    return 0;
}

本篇完。（附下篇链接：）

下篇讲八大排序之一的堆排序。

（穿越回来复习顺便贴个链接：）

数据结构与算法⑫(第四章_中_续一)堆排序（详解）_GR C的博客-CSDN博客

GR鲸鱼
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
chapter5. Java数据结构与java算法
weixin_56137667的博客
08-04 675
一、数据结构和算法概述 数据结构包括：线性结构和非线性结构。 1线性结构 线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系。 一对一e.g. a[0] = 3; 线性结构有两种不同的存储结构，即顺序存储结构(数组)和链式存储结构(链表)。 顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的 链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息（链表可以充分利用碎片内存） 线性结构常见的有：数组、队列、链表和栈，后面我们会详细讲解.
义务教育数学课程标准2022
peicunaaa的博客
03-21 9548
刘畅多次强调，课程教材要发挥培根铸魂、启智增慧的作用，必须坚持马克思主义的指导地位，体现马克思主义中国化最新成果，体现中国和中华民族风格，体现党和国家对教育的基本要求, 体现国家和民族基本价值观，体现人类文化知识积累和创新成果。 义务教育课程规定了教育目标、教育内容和教学基本要求，体现国家意志，在立德树人中发挥着关键作用。2001年颁布的《义务教育课程设置实验方案》和2011年颁布的义务教育各课程标准，坚持了正确的改革方向，体现了先进的教育理念，为基础教育质量提高作出了积极贡献。随着义务教育
数据结构与算法⑫(第四章_中_续一)堆排序（详解）
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
02-26 466
数据结构与算法⑫（第四章_中_续一）八大排序算法之一：堆排序（详解）
数据结构与算法⑩(第四章_上)树和二叉树和堆的概念及结构
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
02-22 361
数据结构与算法⑩（第四章_上）树和二叉树+堆的概念及结构（二叉树，满二叉树，完全二叉树，大堆小堆的性质和存储，二叉树的性质，求父亲下标和孩子下标）
从C语言到C++_20(仿函数+优先级队列priority_queue的模拟实现+反向迭代器)
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
06-19 958
从C语言到C++_20（仿函数+优先级队列priority_queue的模拟实现+反向迭代器）相关笔试题+迭代器的功能分类，到这里基本已经把C++（简单的学了），后面继续融合地讲。
【Redis】《Redis 开发与运维》笔记-汇总
江湖人称菠萝包
04-24 1466
1、Redis提供了两种持久化方式：RDB和AOF，即可以用这两种策略将内存的数据保存到硬盘中。2、复制功能是分布式Redis的基础。3、一般推荐使用的安装方式：源码的方式进行安装。下面以3.0.7版本为例(只需6步)： 建立一个redis目录的软链接是为了不把redis目录固定在指定版本上，有利于Redis未来版本升级，算是安装软件的一个好习惯。 第6步的安装是将Redis的相关运行文件放到/usr/local/bin/下，这样就可以在任意目录下执行Redis的命令。 4、Redis可执行文件说明5、
前端知识体系-全栈系列（图谱+大纲）
热门推荐
https://www.xiaohongshu.com/user/profile/5f3543150000000001002b2e
01-25 1万+
前端知识体系（图谱） 前端工程化体系 node 主流技术栈 大纲 React Vue Angular JavaScript TypeScript 跨平台技术 大纲 跨端技术发展的三个阶段 Hybrid ReactNative Flutter weex 小程序 快应用 ionic Cordova 性能优化和监控 前端知识体系（大纲） 前端工程化体系 基础设施 规范化 前端标准（基础） W3C SPA DOM BOM XHTML XML JSON JSONP HTTP
《算法与数据结构 第_4_章_串.ppt
05-25
《算法与数据结构 第_4_章_串.ppt
数据结构与算法分析--C语言描述_数据结构与算法_
10-01
数据结构与算法是计算机科学的基础，对于理解和设计高效的软件至关重要。C语言因其高效、底层特性，常被用于实现数据结构和算法，使得程序更接近硬件，性能更优。本资源"数据结构与算法分析--C语言描述"是针对数据...
数据结构与算法分析C++语言描述第四版参考答案
10-13
《数据结构与算法分析C++语言描述第四版》是一本深度探讨数据结构和算法的经典教材。这本书由Mark Allen Weiss撰写，旨在帮助读者理解和掌握如何在C++编程环境中有效地设计和实现数据结构及算法。第四版更新了内容，...
《算法与数据结构 第_2_章_线性表.ppt
05-25
《算法与数据结构 第_2_章_线性表.ppt
Windows图形界面(GUI)-MFC-C/C++ - MFC菜单
最新发布
0xCC说逆向
07-25 662
CMenu类：MFC提供的菜单管理类，用于创建和管理菜单。在Visual Studio中，通过资源视图创建菜单资源。菜单类型：顶层菜单（菜单栏）和弹出式菜单（上下文菜单）。参数包括菜单显示位置、对齐方式和拥有者窗口。创建弹出式菜单资源，设置菜单项。宏将菜单ID与消息处理函数关联。在函数中编写菜单命令的处理逻辑。在指定位置显示弹出式菜单。设置菜单项的ID和标题。选中或取消选中菜单项。类型的消息处理函数。工程项目右键资源文件。
数据结构(5.3_3)——由遍历序列构造二叉树
m0_65240792的博客
07-25 267
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
学习记录day19——数据结构 查找算法
weixin_64918301的博客
07-25 405
在给定数据元素的某个值，在查找表中确定一个其关键字等于给定值的数据元素的操作，叫做查找。
java算法原理
jylee的博客
07-25 834
正确回答通过率：40.0%[ 详情 ] 推荐指数： ★★★★ 试题难度： 高难 试题类型： 编程题 ▸ 写笔记试题回答参考思路： >>
数据结构的概念和术语
2303_78660417的博客
07-24 524
数据结构是一门研究非数值计算的程序设计中计算机的操作对象以及它们之间的关系和操作的学科。数据结构的基本数据结构包括两部分，线性结构跟非线性结构。
c语言（7.23）
fhgfyrsg的博客
07-23 734
【代码】c语言（7.23）
数据结构初阶(C语言)-二叉树-顺序表建堆
xiuwoaiailixiya的博客
07-23 1117
int size;}HP;由于堆在本质上是基于顺序表结构去实现的，所以接下来我们所介绍的实现内容重点介绍与顺序表的不同的地方，相同部分则直接给出代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

GR鲸鱼

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

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

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

打赏作者

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

抵扣说明：

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

余额充值