堆的结构及函数接口、堆排序，TopK

最新推荐文章于 2024-07-25 21:13:04 发布
最新推荐文章于 2024-07-25 21:13:04 发布
阅读量723 收藏 27
点赞数 29
分类专栏： 数据结构 文章标签： 算法 开发语言 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_70793373/article/details/128761699
版权

本篇内容涉及到二叉树的概念及性质，可参考文章 树和二叉树的概念及性质

文章目录

一、堆的概念

堆是一颗 完全二叉树，并且数据满足如下性质

  • 如果树中 所有父节点 的值都 大于等于 子节点的值，称作 大堆(最大堆、大根堆)
  • 如果树中 所有父节点 的值都 小于等于 子节点的值，称作 小堆(最小堆、小根堆)

在这里插入图片描述

二、堆的存储结构

在上篇 树和二叉树的概念及性质 的最后，介绍了 完全二叉树的编号，以及 通过某个节点的编号可以轻松的找到该节点的父节点和孩子节点，因此可以 根据编号作为下标 用 数组来存储堆

//堆的数据类型
typedef int HeapDataType;

//堆的结构
typedef struct Heap 
{
	HeapDataType* data;
	int size;	//存储的数据个数
	int capacity;	//当前的容量
}Heap;

在这里插入图片描述

三、堆的函数接口

1. 初始化及销毁

创建一个堆之后，堆结构中的成员变量存储的都是一些随机值，所以需要对其进行初始化，这里采用 初始化时不分配空间 的方式，也可以在初始化时就为其分配一些空间

初始化函数如下：

void HeapInit(Heap* pHp)
{
	//pHp 不能为空指针
  	assert(pHp);

	//初始化
	pHp->data = NULL;
	pHp->size = pHp->capacity = 0;
}

在堆中：存储数据的空间是动态开辟的，不使用时应手动释放

销毁函数如下：

void HeapDestroy(Heap* pHp)
{
	//pHp 不能为空指针
    assert(pHp);

    free(pHp->data);
    pHp->data = NULL;
    pHp->size = pHp->capacity = 0;
}

2. 打印函数

为了验证堆的插入、删除等得到的结果是否正确，提供打印堆的函数，这里数据类型以 int 为例，当读者采用的类型不同时，自行更改该函数即可

打印函数如下：

void HeapPrint(Heap* pHp)
{
    assert(pHp);

    for(int i = 0; i < pHp->size; ++i)
    {
        printf("%d ", pHp->data[i]);
    }
    printf("\n");
}

3. 堆的插入

由于 堆是一颗完全二叉树，因此只能在 最后一个编号之后插入数据，以大堆为例

当 插入的值 小于 父节点的值 时，插入之后的完全二叉树 还是大堆
在这里插入图片描述
当 插入的值 大于 父节点的值 时，插入之后的完全二叉树就 不是大堆 了，此时便 需要将结构调整为大堆
在这里插入图片描述
调整方法：将插入的结点值和父节点值交换，交换之后，如果该值还大于父节点的值，则 继续和父节点交换，直到 交换后的结点值小于等于父节点值 或 该节点已经是根节点

调整过程中，所需要 判断的所有节点都是插入节点的祖先，因此 称作向上调整
在这里插入图片描述

插入函数如下：

//交换值
void Swap(HeapDataType* p1, HeapDataType* p2)
{
    HeapDataType tmp = *p1;
    *p1 = *p2;
    *p2 = tmp;
}

//向上调整，调整时需要存储堆的数组、调整对象编号
void AdjustUp(HeapDataType* array, int child)
{
    assert(array);

    //计算孩子的父节点
    int parent = (child - 1) / 2;

    //交换到根节点后，便停止交换
    while(child > 0)
    {
        //如果孩子节点值大于父节点值，则需要交换父子节点的值，否则调整完成
        //将这里的 大于 改成 小于，就是小堆的的向上调整
        if(array[child] > array[parent]) 
        {
            Swap(&array[child], &array[parent]);
            child = parent;	//父子节点的值已经交换，需要更新孩子的指向
            parent = (child - 1) / 2;	//计算孩子的父节点
        }
        else 
        {
            break;
        }
    }
}

//插入
void HeapPush(Heap* pHp, HeapDataType x)
{
    assert(pHp);

    //扩容
    if(pHp->size == pHp->capacity)
    {
        int newCapacity = pHp->capacity == 0 ? 4 : 2 * pHp->capacity;
        HeapDataType* tmp = (HeapDataType*)realloc(pHp->data, sizeof(HeapDataType) * newCapacity);
        if(tmp == NULL)
        {
            perror("realloc");
            exit(-1);
        }

        pHp->data = tmp;
        pHp->capacity = newCapacity;
    }

    //插入数据
    pHp->data[pHp->size] = x;
    pHp->size++;

    //向上调整
    AdjustUp(pHp->data, pHp->size - 1);
}

4. 堆的删除

堆只会 删除堆顶的数据，删除其他位置的数据意义不大，以大堆为例

由于 数组尾删的效率很高，因此 为了较易删除堆顶的数据，分三步进行

第一步：将 堆顶的数据 和 最后一个数据 交换
在这里插入图片描述
第二步：删除最后一个数据
在这里插入图片描述
第三步：将删除后的完全二叉树 调整为大堆
在这里插入图片描述

调整方法：将较大的孩子结点的值和堆顶节点值交换，交换之后，如果左右孩子中的较大值还大于该值，则 继续将较大的孩子结点的值和该节点值交换，直到 左右孩子的值小于等于交换后的结点值 或 该节点已经是叶节点

调整过程中，所需要 判断的所有节点都是堆顶节点的子孙，因此 称作向下调整
在这里插入图片描述
删除函数如下：

//向下调整，调整时需要存储堆的数组、调整对象编号、堆的数据个数
void AdjustDown(HeapDataType* array, int parent, int n)
{
    assert(array);

    //假设左孩子为需要交换的孩子
    int child = parent * 2 + 1;

	//交换到叶节点，便停止交换
	//完全二叉树中，左孩子不存在，右孩子也就不存在了
    while(child < n)
    {
        //如果假设错误，则需要更新 child 为右孩子
        //需要注意：右孩子可能不存在
        //将这里和下面 if 语句的 大于 改成 小于，就是小堆的向下调整
        if(child + 1 < n && array[child + 1] > array[child]) 
        {
            ++child;
        }

        //如果较大的子节点的值大于父节点的值，则需要交换，否则调整完成
        //将这里和上面 if 语句中的 大于 改成 小于，就是小堆的向下调整
        if(array[child] > array[parent])
        {
            Swap(&array[child], &array[parent]);
            parent = child;	//父子节点的值已经交换，需要更新双亲的指向
            child = parent * 2 + 1;	//假设左孩子为需要交换的孩子
        }
        else 
        {
            break;
        }
    }
}

void HeapPop(Heap* pHp)
{
    assert(pHp);
    assert(!HeapEmpty(pHp));

    //第一步：交换堆顶和最后一个数据
    Swap(&pHp->data[0], &pHp->data[pHp->size - 1]);

    //第二步删除最后一个数据
    pHp->size--;

    //第三步：向下调整
    AdjustDown(pHp->data, 0, pHp->size);
}

5. 取堆顶、判空、数据个数

这些函数较为简单，就不做分析了

函数如下：

//取堆顶
HeapDataType HeapTop(Heap* pHp)
{
    assert(pHp);
    assert(!HeapEmpty(pHp));

    return pHp->data[0];
}

//判空
bool HeapEmpty(Heap* pHp)
{
    assert(pHp);

    return pHp->size == 0;
}

//数据个数
size_t HeapSize(Heap* pHp)
{
    assert(pHp);

    return pHp->size;
}

四、建堆算法和时间复杂度

数组 array { 25, 15, 51, 30, 20, 19 }，交换数组元素使之变为堆，要求空间复杂度为 O(1)

1. 向上调整建堆

将数组的元素看做一棵完全二叉树
在这里插入图片描述
在堆的插入中，插入数据之前，数组本身是堆，当插入的数据大于父节点时，通过向上调整，便可以将数组调整为堆

为了可以使用向上调整算法，需要满足调整之前数组本来就是堆

当数组只有一个元素时，可以将其看做一个堆，于是便可以不断的对新数据进行向上调整，最终就可以将整个数组调整为堆
在这里插入图片描述

调整结果：
在这里插入图片描述

向上调整函数 已经在 堆的插入给出，建堆循环 如下：

//数组和数组大小
int array[] = { 25, 15, 51, 30, 20, 19 };
int len = sizeof(array)/sizeof(array[0]);

//向上调整建堆
//时间复杂度：O(N * logN)
for(int i = 1; i < len; ++i)
{
	AdjustUp(array, i);	//对新数据进行向上调整
}

向上调整建堆的时间复杂度：
在这里插入图片描述
对于高度为 h 的堆，总节点数 N = 2h - 1，总调整次数：

F(h) = 21 * 1 + 22 * 2 + … + 2h - 1 * (h - 1)
小于 2 * 2h - 1 * (h - 1) = 2h * (h - 1) = (N + 1) * (log2(N + 1) - 1)

因此向上调整建堆的时间复杂度为 O(N * log2N)

2. 向下调整建堆

将数组的数据看做一棵完全二叉树：
在这里插入图片描述
在堆的删除中：先将堆顶和最后一个数据交换，然后删除最后一个数据，此时堆顶的左子树和右子树均是堆，通过向下调整，便可以将数组调整为堆

为了可以使用向下调整算法，需要满足调整的节点的左子树和右子树均是堆

显然数组的第一个数据的左子树和右子树不是堆，此时并不能从第一个开始向下调整，而是需要从最后一个节点开始，从后往前对每一个节点向下调整

由于数组只有一个元素时，可以将其看做一个堆，因此可以 从最后一个分支节点开始，在完全二叉树中，最后一个分支节点就是最后一个节点的父节点，最后便可以将数组调整为堆
在这里插入图片描述

调整结果：
在这里插入图片描述

向下调整函数 已经在 堆的删除给出 ，建堆循环 如下：

//数组和数组大小
int array[] = { 25, 15, 51, 30, 20, 19 };
int len = sizeof(array)/sizeof(array[0]);

//向下调整建堆
//时间复杂度O(N)
//从最后一个分支节点开始，从后往前
for(int i = (len - 1 - 1) / 2; i >= 0; --i)
{
	AdjustDown(array, i, len);	//向下调整为堆，为后续向下调整做准备
}

时间复杂度
在这里插入图片描述
对于高度为 h 的堆，总节点数 N = 2h - 1，总调整次数：

F(h) = 20 * (h - 1) + 21 * (h - 2) + … + 2h - 3 * 2 + 2h - 2 * 1
2 * F(h) = 21 * (h - 1) + 22 * (h - 2) + … + 2h - 2 * 2 + 2h - 1 * 1

2 * F(h) - F(h) 错位相减得：
F(h) = - 20 * (h - 1) + 21 * 1 + … + 2h - 3 * 1 + 2h - 2 * 1 + 2h - 1 * 1
F(h) = 2h - 2 - (h - 1) = 2h - 1 - h = N - log2N

因此向下调整建堆的时间复杂度为 O(N)

五、堆排序和 TopK 问题

对数组 array { 25, 15, 51, 30, 20, 19 } 进行原地排序，升序建大堆，降序建小堆

在这里插入图片描述
堆排序时间复杂度：O(N * log2N)，计算方法和向上调整建堆相似

堆排序函数如下：

void HeapSort(int* array, int arrayLen)
{
    //升序建大堆
    for(int i = (arrayLen - 1 - 1) / 2; i >= 0; --i)
    {
        AdjustDown(array, i, arrayLen);
    }

	//每一次将堆顶和最后一个数据交换，并且不将最后一个数据看做堆的数据，进行向下调整为堆
	//如果升序建小堆，出的数据没有存放的地方
    int end = arrayLen - 1;
    while(end > 0)
    {
        Swap(&array[0], &array[end]);
        AdjustDown(array, 0, end);
        --end;
    }
}

排序过程：
在这里插入图片描述
选取数据中前 K 个最大数据或最小数据，一般数据量都很大，无法存储在内存中

选取前 K 个最大数据，建 K 个数据的小堆，选取前 K 个最小数据，建 K 个数据的大堆

时间复杂度：K + (N - K) * log2K -> O(N * log2K)
空间复杂度：O(K)

//用于测试
void arrayPrint(int* array, int arrayLen)
{
    for(int i = 0; i < arrayLen; ++i)
    {
        printf("%d ", array[i]);
    }
    printf("\n");
}

void HeapTest5()
{
    int n = 10000;  //数据个数
    int k = 5;  //选取的 K 个数

    //设置随机数种子
    srand((unsigned)time(NULL));

    FILE* fin = fopen("data.txt", "w");
    if(fin == NULL)
    {
        perror("fopen");
        exit(-1);
    }

    //制造数据
    for(int i = 1; i <= n; ++i)
    {
        int val = rand() % 100;
        fprintf(fin, "%d ", val);

        //制造 2k 个较大的数
        if(i % (n / k / 2) == 0)
        {
            fprintf(fin, "%d ", i * 100 + val);
        }
    }

    fclose(fin);

	//创建 k 个空间，用来存储堆
    int* array = (int*)malloc(sizeof(int) * k);
    if(array == NULL)
    {
        perror("malloc");
        exit(-1);
    }

    FILE* fout = fopen("data.txt", "r");
    if(fout == NULL)
    {
        perror("fopen");
        exit(-1);
    }

    //读取前 k 个数据
    for(int i = 0; i < k; ++i)
    {
        fscanf(fout, "%d", &array[i]);
    }

    //arrayPrint(array, k);

    //建小堆
    for(int i = (k - 1 - 1) / 2; i >= 0; --i)
    {
        AdjustDown(array, i, k); 
    }

    //arrayPrint(array, k);
    
    //遍历数据
    int val = 0;
    while(fscanf(fout, "%d", &val) != EOF)
    {
    	//比堆顶大就替换堆顶，然后调整为小堆
        if(array[0] < val)
        {
            array[0] = val;
            AdjustDown(array, 0, k);
        }
    }

    arrayPrint(array, k);

    fclose(fout);
}

int main()
{
    HeapTest5();

    return 0;
}
[Pokemon]大猫猫
关注
  • 29
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 25
    评论
专栏目录
堆排序问题（TOP-K问题）
！
04-08 1194
了解如何建堆，什么时候建大堆，小堆(建堆调整算法比较等），topk问题解析等.......
C/C++ 通过最大堆求topk
04-09
在计算机科学和编程领域，"通过最大堆求topk"是一种高效的算法，常用于寻找一个大数组中的前k个最大元素。这个算法的核心是利用数据结构——最大堆（Max Heap）来实现。最大堆是一种完全二叉树，其中每个父节点的值...
【数据结构入门】堆的应用：TopK & 堆排序
codewinter的博客
02-28 3962
文章目录一、Top-k问题1.1 解法一：暴力排序1.2 解法二：建N个数的堆1.3 解法三：建K个数的堆（最优解法）二、堆排序 一、Top-k问题 Top-k问题：在 N 个数中，找出前 K 个（最大/最小）的元素，一般情况下数据量 N 都远大于 k。 Top-k问题在生活中是非常的常见，比如游戏中某个大区某个英雄熟练度最高的前10个玩家的排名，我们就要根据每个玩家对该英雄的熟练度进行排序，可能有200万个玩家，但我只想选出前10个，要对所有人去排个序吗？显然没这个必要。 再比如：专业前10名、世界50
【算法与数据结构】堆排序&&TOP-K问题
a_sen的博客
03-17 2263
堆排序即利用堆的思想来进行排序，总共分为两个步骤： 代码运行： TOP-K问题是数据挖掘和信息检索中的一个重要问题。TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。 TOP-K问题是数据挖掘和信息检索中的一个重要问题。TOP-K问题的含义是:给定一个集合,找出其中值最大或最小的前K个元素。常见的TOP-K问题有:查找文档集合中与查询条件最相关的前K篇文档。这在搜索引擎中很常见。从用户评分最高的物品中找出前K个最受欢迎的物品。从数据库中找出收入前K高的用户。从候选
解密堆排序与TopK问题
2202_75605090的博客
09-20 1145
在二叉树的存储结构中提到堆可以进行排序，也就是今天的主题堆排序，堆的排序还可以解决Topk问题，今天我就向大家解密什么是堆排序和Topk问题，它们的原理又是什么。Top-K问题是指从一组元素中找出前K个最大（或最小）的元素。这个问题在数据处理和算法设计中经常遇到，常见的应用场景包括搜索引擎中的搜索结果排序、推荐系统中的物品推荐、数据分析中的数据筛选等。找出前K个最大的元素。
堆排序之“TOP-K”问题
Han同学
11-01 1126
堆排序之“TOP-K”问题
【数据结构】利用堆解决TopK问题
有道无术, 术尚可求。有术无道, 止于术。
11-30 1752
本篇将详细讲解如何利用小根堆的方法解决TopK问题。
＜ 数据结构 ＞ 堆的应用 --- 堆排序和Topk问题
bit_zyx的博客
04-18 1211
目录 1、堆排序 法一：自己写堆进行排序 时间复杂度分析 法二：直接对数组建堆 ①、向上调整建堆 ②、向下调整建堆 向上建堆和向下建堆熟优？ 升序能否建小堆？ 排序（建大堆） 2、TopK问题 何为Topk？ 实现过程 1、堆排序 假如我们有一串乱序数组，如...
堆结构的两个重要应用（topk问题，堆排序）
qq_52777887的博客
03-19 1500
堆结构体有什么用？堆排序 & topK 你值得拥有
堆排序——高效解决TOP-K问题
2203_75397752的博客
01-14 1398
堆是一种特殊的完全二叉树，其中每个父节点的值都大于或等于其子节点的值（最大堆），或者每个父节点的值都小于或等于其子节点的值（最小堆）。在堆排序中，我们通常使用最大堆。TOP-K问题是指在一个大数据集中找到前K个最大或最小的元素。这个问题在多个领域都非常常见，比如排名、选举、统计和游戏等。常见的例子包括找到考试成绩中的前10名、世界500强企业或者游戏中最活跃的100名玩家。当数据量非常大时，简单的排序方法可能会因为数据量超过内存限制而变得不可行。此外，完整的排序操作的时间复杂度为O(nlogn)
教你用堆排序解决topk问题
程序员学编程 的专栏
01-24 2098
教你用堆排序解决topk问题，同时学会堆排序。 1、什么是Top K问题？ 找到数组中最大（最小）的K个数，例如7,6,3,5,2，Top3 的意思就是 找出最小的三个数即为：3,5,2。 方法1：对数组全部排序，然后根据要求取其中K个数 方法2：只对K个排序，例如冒泡是一个很常见的排序方法，每冒一个泡，找出最大值，冒k个泡，就得到TopK。 方法3：就是本文主要要讲的堆，构建一个大顶堆(小顶堆)，然后堆顶就是最大值（最小值）取出最大值后调整堆，再继续取堆顶值，取到k为止。 看完了topk的问题，我们现
基于PHP实现堆排序原理及实例详解
10-15
然而，堆排序在求解TopK问题时特别有用，因为它只需要进行K轮排序，时间复杂度为O(Klog2(n))。这使得堆排序在处理大数据集时，特别是需要找出前K个最大或最小元素的情况下，表现优秀。 总的来说，堆排序是利用堆的...
数据结构之堆详解
09-04
- **堆排序**：堆排序是一种原地排序算法，时间复杂度为O(N log N)。通过构建大顶堆或小顶堆，可以高效地实现升序或降序排序。 - **合并有序表**：在O(n log k)的时间内，可以将k个已排序的表合并成一个有序表。堆...
堆排序
02-22
堆排序常用于需要在线性时间复杂度内找到最大或最小元素的情况，例如在求解Top-K问题时。此外，堆排序也是优先队列的一种常见实现方式。 总之，堆排序是计算机科学中一种重要的排序算法，它通过构建和操作堆来达到...
最大K个数问题的Python版解法总结
12-23
在编程领域，TopK问题是一个常见的数据处理任务，它的目标是从大量数据中找出最大的K个元素。本篇文章主要探讨了三种解决此问题的Python方法，包括排序、最大堆以及快速选择算法。 首先，方法一是通过排序来解决。...
算法-KMP字符串匹配
xx_xb的博客
07-23 178
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
【LeetCode】141.环形链表、142. 环形链表 II（算法 + 图解）
最新发布
明志の博客
07-25 859
环形链表
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 660
AtCoder Beginner Contest 363 ABCDE
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
danaaaa的博客
07-24 757
二叉搜索树向左或向右指明方向，不用遍历整个树。
使用堆与哈希解决TopK问题及Java中的TreeMap分析
"本文主要探讨了在阿里巴巴的背景下，如何高效地解决TopK问题，即找出数组中的前K个最大数。文中提到了四种方法，包括快速排序、维护固定...在处理TopK问题时，哈希表结合最小堆的方法往往能提供较好的性能和灵活性。
评论 25
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值