C语言实现基本数据结构——堆

最新推荐文章于 2024-07-20 09:51:47 发布
最新推荐文章于 2024-07-20 09:51:47 发布
阅读量789 收藏 16
点赞数 24
分类专栏： 数据结构与算法 文章标签： 算法 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73281594/article/details/136357055
版权
本文详细介绍了堆数据结构的实现，包括堆的定义、不同类型（最大堆和最小堆）、初始化、销毁、数据插入和移除方法，以及向上和向下调整算法。特别强调了堆的特点和操作中需要注意的细节，如堆的性质和调整策略。
摘要由CSDN通过智能技术生成

目录

堆

堆的实现

堆的类型定义

堆的功能实现（以小堆为例）

堆的初始化

堆的销毁

堆的数据插入

堆的数据移除

判断堆是否为空

获取堆顶数据

获取堆的有效数据个数

项目文件

堆

如果有一个关键码的集合，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，则称为堆

将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆

堆的特点：

  1. 堆中某个节点的值总是不大于或不小于其父节点的值
  2. 堆总是一棵完全二叉树
  3. 二叉树中父子间下标关系
  • 孩子节点找父亲节点：左孩子leftChild = parent * 2 + 1，右孩子rightChild = parent * 2 + 2
  • 父亲节点找孩子节点：parent = (child - 1) / 2（不论孩子节点下标为奇数还是偶数均可以使用，因为当child为奇数时，会进行取整操作）

堆的实现

堆的类型定义

// 定义堆中存储的数据的数据类型
typedef int HPDataType；
// 堆的结构设计
typedef struct Heap
{
    HPDataType* data;// 存储数据部分
    int size; // 堆中的有效数据个数
    int capacity; // 堆的容量大小
}HP;

堆的功能实现（以小堆为例）

// 主要实现功能
// 堆的初始化
void HeapInit(HP* hp);
// 堆的销毁
void HeapDestroy(HP* hp);
// 堆的数据插入
void HeapPush(HP* hp, HPDataType x);
// 堆的数据删除
void HeapPop(HP* hp);
// 获取堆顶数据
HPDataType HeapTop(HP* hp);
// 判断堆是否为空
bool IsEmpty(HP* hp);

堆的初始化

// 堆的初始化
void HeapInit(HP* hp)
{
    hp->data = NULL;
    hp->size = hp->capacity = 0;   
}

堆的销毁

// 堆的销毁
void HeapDestroy(HP* hp)
{
    assert(hp);
    free(hp->data);
    hp->size = hp->capacity = 0;
}

堆的数据插入

对于堆的数据插入过程来说（以小堆为例），在小堆中，父亲节点的值总小于或等于孩子节点的值，故可以采用向上调整算法，但是使用向上调整算法的前提是除插入数据以外，原始的堆已经为小堆

//以下面的数组为例
int arr[6] = { 35,70,56,90,60,25};

首先插入35，因为一个节点依旧为堆，而且此时无法判断是小堆还是大堆，故不需要调整，直接插入即可

第二个数值为70，因为70>35，故不需要进行向上调整，直接插入即可

第三个数值为56，因为56>35，故不需要进行向上调整，直接插入即可

📌

注意不需要关注兄弟节点之间的关系和顺序

第四个数值为90，因为90>70，故不需要进行向上调整，直接插入即可

第五个数值为60，因为60<70，此时需要进行向上调整，当前的size位置即为需要调整的孩子节点的位置的后一个位置

第六个数值为25，因为25<56，此时需要向上调整，并且因为25比根节点也小，所以需要向上调整两次，当前size-1的位置即为孩子节点25的位置

📌

注意，判断循环条件为child > 0，而不是parent >= 0，因为当child为0时，说明已经到了根节点，就不需要再进行向上调整了，而如果使用parent >= 0作为循环条件，那么当child为0是，parent = (child - 1) / 2算出来的值依旧是0，导致出现死循环

//交换函数
void swap(HPDataType* num1, HPDataType* num2)
{
    HPDataType* tmp = num1;
    *num1 = *num2;
    *num2 = *tmp;
}

//向上调整算法
void AdjustUP(HPDataType* data, int size, int child)
{
    int parent = (child - 1) / 2;//计算父亲节点的位置
    while (child > 0)
    {
        if (data[child] < data[parent])
        {
            //交换孩子节点和父亲节点的值
            swap(&data[child], &data[parent]);

            child = parent;//更新孩子节点为原父亲节点的位置
            parent = (child - 1) / 2;// 获取下一个父亲节点的位置
        }
        else
        {
            break;// 如果有一次出现孩子节点大于父亲节点的值就直接跳出不需要进行接下来的比较，因为其他位置在执行前已经是小堆
        }
    }
}

// 堆的数据插入
void HeapPush(HP* hp, HPDataType x)
{
    assert(hp);
    //判断是否需要扩容
    if (hp->size == hp->capacity)
    {
        int newCapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
        HPDataType* tmp = (HPDataType*)realloc(sizeof(HPDataType) * newCapacity);
        assert(tmp);
        hp->data = tmp;
        hp->capacity = newCapacity;
    }
    hp->data[hp->size++] = x;
    //插入数据
    //以小堆为例，在小堆中，父亲节点的值总小于或等于孩子节点的值
    //所以需要进行向上调整
    //向上调整的前提是其余的内容已经是小堆
    AdjustUP(hp->data, hp->size, hp->size - 1);
}

堆的数据移除

在堆中，移除的数据均为堆的第一个数据，即根节点的数据，但是不能直接使用挪动覆盖的思路，因为会打破原有的堆结构，可以采用先交换根节点和叶子节点的数据再使用向下调整算法恢复小堆结构

先交换根节点和叶子节点的数据，再改变size的值，从而达到删除数据的效果

接着执行向下调整算法恢复堆结构

在执行向下调整算法时，需要判断是和哪一个孩子节点进行交换，找到较小的孩子的节点交换即可

//向下调整算法
void AdjustDown(HPDataType* data, int size, int parent)
{
    int child = parent * 2 + 1;//假设左边的孩子节点为较小的孩子节点
    while (child < size)
    {
        //如果假设不正确，则改变需要进行交换的孩子节点
        if (child + 1 < size && data[child] > data[child + 1])//先判断child+1是否越界
        {
            child++;// 将child更改为右边的孩子节点
        }
        //执行交换
        if (data[child] < data[parent])
        {
            swap(&data[child], &data[parent]);

            parent = child;//更新parent值便于继续比较下一层
            child = parent * 2 + 1;//更新child的值
        }
        else
        {
            break;
        }
    }
}

// 堆的数据删除
void HeapPop(HP* hp)
{
    assert(hp);
    //堆为空不执行删除操作
    assert(!IsEmpty(hp));

    //在堆中，删除的数据并不是最后一个元素，而是第一个元素
    //但是不可以直接挪动数据，否则会改变节点之间的关系，从而失去堆的结构
    //可以考虑使用先交换根节点和最后一个叶子节点数据再使用向下调整算法解决问题
    //交换根节点数据和最后一个叶子节点数据
    swap(&(hp->data[0]), &(hp->data[hp->size - 1]));
    hp->size--;
    //向下调整算法恢复堆结构
    AdjustDown(hp->data, hp->size, 0);
}

判断堆是否为空

// 判断堆是否为空
bool IsEmpty(HP* hp)
{
    assert(hp);
    return hp->size == 0;
}

获取堆顶数据

//获取堆顶数据
HPDataType HeapTop(HP* hp)
{
    assert(hp);
    assert(!IsEmpty(hp));

    return hp->data[0];
}

获取堆的有效数据个数

//获取堆的有效数据个数
int HeapSize(HP* hp)
{
    assert(hp);
    return hp->size;
}

 

项目文件

//头文件
#pragma once

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

// 定义堆中存储的数据的数据类型
typedef int HPDataType;
// 堆的结构设计
typedef struct Heap
{
    HPDataType* data;// 存储数据部分
    int size; // 堆中的有效数据个数
    int capacity; // 堆的容量大小
}HP;

// 堆的初始化
void HeapInit(HP* hp);
// 堆的销毁
void HeapDestroy(HP* hp);
//交换函数
void swap(HPDataType* num1, HPDataType* num2);
//向上调整算法
void AdjustUP(HPDataType* data, int child);
// 堆的数据插入
void HeapPush(HP* hp, HPDataType x);
//向下调整算法
void AdjustDown(HPDataType* data, int size, int parent);
// 堆的数据删除
void HeapPop(HP* hp);
// 获取堆顶数据
HPDataType HeapTop(HP* hp);
// 判断堆是否为空
bool IsEmpty(HP* hp);
//获取堆的有效数据个数
int HeapSize(HP *hp);

//实现文件
#define _CRT_SECURE_NO_WARNINGS 1

#include "Heap.h"

// 堆的初始化
void HeapInit(HP* hp)
{
    hp->data = NULL;
    hp->size = hp->capacity = 0;
}

// 堆的销毁
void HeapDestroy(HP* hp)
{
    assert(hp);
    free(hp->data);
    hp->size = hp->capacity = 0;
}

//交换函数
void swap(HPDataType* num1, HPDataType* num2)
{
    HPDataType tmp = *num1;
    *num1 = *num2;
    *num2 = tmp;
}

//向上调整算法
void AdjustUP(HPDataType* data, int child)
{
    int parent = (child - 1) / 2;//计算父亲节点的位置
    while (child > 0)
    {
        if (data[child] < data[parent])
        {
            //交换孩子节点和父亲节点的值
            swap(&data[child], &data[parent]);

            child = parent;//更新孩子节点为原父亲节点的位置
            parent = (child - 1) / 2;// 获取下一个父亲节点的位置
        }
        else
        {
            break;// 如果有一次出现孩子节点大于父亲节点的值就直接跳出不需要进行接下来的比较，因为其他位置在执行前已经是小堆
        }
    }
}

// 堆的数据插入
void HeapPush(HP* hp, HPDataType x)
{
    assert(hp);
    //判断是否需要扩容
    if (hp->size == hp->capacity)
    {
        int newCapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
        HPDataType* tmp = (HPDataType*)realloc(hp->data, sizeof(HPDataType) * newCapacity);
        assert(tmp);
        hp->data = tmp;
        hp->capacity = newCapacity;
    }
    hp->data[hp->size++] = x;
    //插入数据
    //以小堆为例，在小堆中，父亲节点的值总小于或等于孩子节点的值
    //所以需要进行向上调整
    //向上调整的前提是其余的内容已经是小堆
    AdjustUP(hp->data, hp->size - 1);
}

//向下调整算法
void AdjustDown(HPDataType* data, int size, int parent)
{
    int child = parent * 2 + 1;//假设左边的孩子节点为较小的孩子节点
    while (child < size)
    {
        //如果假设不正确，则改变需要进行交换的孩子节点
        if (child + 1 < size && data[child] > data[child + 1])//先判断child+1是否越界
        {
            child++;// 将child更改为右边的孩子节点
        }
        //执行交换
        if (data[child] < data[parent])
        {
            swap(&data[child], &data[parent]);

            parent = child;//更新parent值便于继续比较下一层
            child = parent * 2 + 1;//更新child的值
        }
        else
        {
            break;
        }
    }
}

// 堆的数据删除
void HeapPop(HP* hp)
{
    assert(hp);
    //堆为空不执行删除操作
    assert(!IsEmpty(hp));

    //在堆中，删除的数据并不是最后一个元素，而是第一个元素
    //但是不可以直接挪动数据，否则会改变节点之间的关系，从而失去堆的结构
    //可以考虑使用先交换根节点和最后一个叶子节点数据再使用向下调整算法解决问题
    //交换根节点数据和最后一个叶子节点数据
    swap(&(hp->data[0]), &(hp->data[hp->size - 1]));
    hp->size--;
    //向下调整算法恢复堆结构
    AdjustDown(hp->data, hp->size, 0);
}

// 判断堆是否为空
bool IsEmpty(HP* hp)
{
    assert(hp);
    return hp->size == 0;
}

// 获取堆顶数据
HPDataType HeapTop(HP* hp)
{
    assert(hp);
    assert(!IsEmpty(hp));

    return hp->data[0];
}
//获取堆的有效数据个数
int HeapSize(HP* hp)
{
    assert(hp);
    return hp->size;
}

//测试文件
#define _CRT_SECURE_NO_WARNINGS 1

#include "Heap.h"

void Test()
{
    HP hp = { 0 };
    HeapInit(&hp);
    //int a[] = { 65,100,70,32,50,60 };
    int a[] = { 35,70,56,90,60,25 };
    for (int i = 0; i < sizeof(a) / sizeof(int); i++)
    {
        HeapPush(&hp, a[i]);
    }

    while (!IsEmpty(&hp))
    {
        printf("%d ", HeapTop(&hp));
        HeapPop(&hp);
    }

    HeapDestroy(&hp);
}

int main()
{
    Test();

    return 0;
}
怡晗★
关注
  • 24
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构——单链表的实现(c语言版）
m0_68641696的博客
08-12 997
虽然单链表有一定的缺陷，但是单链表也有它存在的价值， 它也是作为其他数据结构的一部分出现的，比如在图，哈希表中。由于单链表结构的限制，这里只实现了在pos位置之后的插入和删除，如果删除pos的后一个节点就需要确保pos的后一个节点是存在的，否则就会出现问题。尾插也分为链表为空和指针不为空的情况，如果链表为空，申请节点，让链表的头结点指向申请的节点，然后将这个节点的。，如果链表不为空，首先需要找到尾结点，然后将尾结点与这个节点链接起来，再将这个新申请的节点的。5.查找链表的值和修改链表节点的值。
数据结构顺序表C语言实现（无废话,代码纯享版）
GDYJLXQ的博客
10-17 41
采用C语言实现数据结构的顺序表
数据结构——堆（C语言实现）
sinzz的博客
06-11 2483
本篇文章主要介绍了堆的概念、堆的实现、堆排序的实现、建堆和堆排序时间复杂度的讲解、以及简单介绍了TOPK问题。
C语言数据结构学习——链栈
link_on_line的博客
11-25 142
#include <stdio.h> #include <stdlib.h> typedef struct LinkStack { int data; struct LinkStack* next; }LinkStack; LinkStack* push(LinkStack * stack, int a) { LinkStack* line = (LinkStack*)malloc(sizeof(LinkStack)); line->data = a; line
栈的基本操作 C语言 数据结构
WindsProgrammer的博客
06-03 1609
大概80行代码，如下，有需要自取。（数据结构教程 第五版 李春葆） 这次实验是顺序栈的操作，其中取栈顶元素的操作根据自己的情况取舍。 #include <stdio.h> #include <malloc.h> #define MaxSize 100 typedef char ElemType; typedef struct { ElemType data[MaxSize]; int top; }SeqStack; void InitStack(SeqStack *&
数据结构——基于C语言实现杨辉三角
08-11
C语言是一种底层编程语言，它允许直接操作内存，因此非常适合实现数据结构。 首先，让我们了解杨辉三角。杨辉三角，又称帕斯卡三角，是二项式系数的一种图形表示，具有对称的形状。在每个位置上，数字是其上方两个...
C语言数据结构 顺序栈——进制转换
03-16
各种进制转换十转二十转八十转十六 二八十六转十 C语言 .c文件 具体界面看这里：https://blog.csdn.net/yyueyuerr/article/details/123520587
数据结构——链表 C语言
03-16
设单链表A和B均非递减有序，试设计算法，将A和B合并成非递增有序的单链表C，并要求利用原表A和B的结点空间构造表C。
C语言数据结构——学生选课管理系统（哈希存储结构实现）
03-12
《C语言数据结构——学生选课管理系统（哈希存储结构实现）》 本文将探讨一个基于C语言的数据结构实现——学生选课管理系统，该系统利用哈希存储结构来高效地管理大量学生和课程信息。系统的主要功能包括增加、删除...
数据结构——基于C语言实现二叉树的应用.cpp
08-11
/创建二叉树 //初始化二叉树 //创建队列 //出队 //队列判空 //入队 //先序递归遍历 //后序递归遍历 //中序递归遍历 //层次遍历
排序算法(4)之快速排序(1)
wer24_25的博客
07-17 1136
排序算法(4)之快速排序(1),快速排序的概念和快速排序的三种实现方式.
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 216
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 279
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
排序思想-快排
m0_58257626的博客
07-17 338
快速排序核心思想就是每次在当前区间 [left, right] 中选择出一个元素 nums[p]，然后将区间内所有大于它的元素和所有小于它的元素都放到其两侧【具体放在哪一侧取决于是升序还是降序】，然后再递归去处理两侧区间。将大于切分值的元素都放到左侧，小于切分值得元素都放到右侧。因此我们可以使用双指针分别从两端往中间搜索，分别找到左侧小于切分值的元素和右侧大于切分值的元素，交换之，直到两个指针相遇。
完全二叉树的节点个数-递归
qq_45031559的博客
07-19 250
完全二叉树的节点个数-递归
算法刷题笔记 排列数字（C++实现）
hanmo22357的博客
07-17 279
一道简单的深度优先搜索（DFS）模板题，给出了DFS问题的一般思路以及C++代码实现
24暑假算法刷题 | Day15 | LeetCode 110. 平衡二叉树，257. 二叉树的所有路径，404. 左叶子之和，222. 完全二叉树的节点个数
weixin_54468359的博客
07-17 1144
day15打卡：二叉树的递归与迭代
python实现图像缩放算法
最新发布
qq_42568323的博客
07-20 295
它通过选择离目标像素最近的原始像素的颜色值来确定目标像素的颜色值。它通过考虑目标像素周围16个像素的颜色值，使用双三次插值公式计算出目标像素的颜色值。相较于双线性插值，双三次插值能生成更平滑、更细腻的图像效果。它通过考虑目标像素周围四个像素的颜色值，使用双线性插值公式计算出目标像素的颜色值。尽管最近邻插值在某些应用场景中足够使用，但在需要更高质量图像的场景中，通常会选择更加复杂的插值方法，如双线性插值或双三次插值。双三次插值是图像缩放中高质量的方法之一，适合需要高质量图像处理的应用场景。
(算法)区间调度问题
2202_75519246的博客
07-17 224
此外,参与工作的时间段不能重复(即使是开始的瞬间和结束的瞬间的重叠也是不允许的). 你的目标是参与尽王多的工作,那么最多能参与多少项工作呢?有n项工作,每项工作分别在s时间开始,在t时间结束. 对于每项工作,你都可以选择参与与否,如果选择了参与,那么自始至终都必须全程参与.
C语言版《数据结构》实验指导——严蔚敏
"《数据结构》(C语言版)严蔚敏著-数据结构实验指导" ...通过这些实验，学生不仅能巩固C语言基础知识，还能逐步掌握数据结构中的链表、树、图等抽象数据类型的实现方法，为后续深入学习数据结构打下坚实基础。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

怡晗★

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

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

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

打赏作者

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

抵扣说明：

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

余额充值