【数据结构】堆的实现和堆排序--TOP-K问题

2024-06-21 18:52
文章标签 实现 问题 数据结构 top 堆排序

本文主要是介绍【数据结构】堆的实现和堆排序--TOP-K问题，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

前言：

堆是一种特殊的树形数据结构，常用于实现优先队列和堆排序。它基于完全二叉树，通常用数组表示。主要操作包括插入（通过上滤维护堆性质）和删除（通常删除堆顶元素，通过下滤恢复堆性质）。

堆排序是一种基于堆的排序算法。它首先将待排序序列构造成一个堆，然后不断将堆顶元素与末尾元素交换并重新调整堆，直至整个序列有序。堆排序的时间复杂度为O(nlogn)，空间复杂度为O(1)。

在信息过载的时代，如何从海量数据中快速找出最重要的K个元素，即TOP-K问题，已成为数据处理和分析的关键挑战。TOP-K问题在广告推荐、搜索引擎、社交网络等领域具有广泛应用，对于提升用户体验和决策效率至关重要。

1.堆的概念及结构

如果有一个关键码的集合K = { ， ， ，…， }，把它的所有元素按完全二叉树的顺序存储方式存储 在一个一维数组中，并满足：Ki<=K2*i+1且Ki<=K2*i+2(Ki >=K2*i+1 且Ki >=K2*i+2 ) i = 0，1， 2…，则称为小堆(或大堆)。将根结点最大的堆叫做最大堆或大根堆，根结点最小的堆叫做最小堆或小根堆。

堆的性质：

1.堆中某个结点的值总是不大于或不小于其父结点的值

2.堆总是一棵完全二叉树。

大堆的特点就是根最大，小堆的特点就是根是最小

2.堆的实现

堆逻辑上是一颗树，物理上是数组

2.1 堆的定义与接口声明

在头文件中进行堆的定义和接口的声明

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>typedef int HPDataType;typedef struct Heap
{HPDataType* a;int size;int capacity;
}HP;//堆的初始化
void HPInit(HP* php);//堆的销毁
void HPDestroy(HP* php);//堆的插入
void HPPush(HP* php, HPDataType x);//堆的删除
void HPPop(HP* php);//取堆顶的数据
HPDataType HPTop(HP* php);// 堆的数据个数
int HPsize(HP* php);//堆的判空
bool HPEmpty(HP* php);

2.2 初始化与销毁

//堆的初始化
void HPInit(HP* php)
{assert(php);php->a = NULL;php->size = php->capacity = 0;
}
//堆的销毁
void HPDestroy(HP* php)
{assert(php);free(php->a);php->a = NULL;php->size = php->capacity = 0;
}

这里的方法与顺序表相同就不多赘述了

2.3 堆中插入数据

这里的插入数据和顺序表的插入截然不同，这里我们在初始化的时候并没有开辟空间，所以我们插入数据之前需要申请空间，这里与顺序表的不同之处在于插入完数据之后这仍要是个堆，比如我们需要创建一个小堆那么就需要向上调整

//堆的插入
void HPPush(HP* php, HPDataType x)
{assert(php);if (php->size == php->capacity){int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;HPDataType* tmp = (HPDataType*)realloc(php->a, newcapacity * sizeof(HPDataType));if (tmp == NULL){perror("realloc fail");return;}php->a = tmp;php->capacity = newcapacity;}php->a[php->size] = x;php->size++;//向上调整AdjustUp(php->a, php->size - 1);
}

先插入一个10到数组的尾上，再进行向上调整算法，小于父节点就交换位置，直至对比到根位置

void Swap(HPDataType* p1, HPDataType* p2)
{HPDataType tmp = *p1;*p1 = *p2;*p2 = tmp;
}
//向上调整
void AdjustUp(HPDataType* a, int child)
{//初始条件//中间过程//结束条件int parent = (child - 1) / 2;while (child > 0){if (a[child] < a[parent]){Swap(&a[child], &a[parent]);child = parent;parent = (child - 1) / 2;}else{break;}}}

2.4 堆的删除

我们删除堆顶的数据可以直接删除吗？如果直接删除的话那么岂不是兄弟关系变成父子关系，这样肯定是不对的，我们需要确保删除之后还是个堆

那么我们可以让堆顶的数据与最后一个数据进行交换然后直接size--即可，然后我们需要向下调整一下，通过向下调整操作来恢复堆的性质，确保父节点的值始终小于或等于其子节点的值（对于最小堆）。

//堆的删除
void HPPop(HP* php)
{assert(php);assert(php->size > 0);Swap(&php->a[0], &php->a[php->size - 1]);php->size--;//向下调整AdjustDown(php->a, php->size, 0);
}

向下调整

这里需要分别检查左孩子和右孩子哪个小，小的那个去和父节点进行比较，如果小于父节点就交换（小堆），直至调整到叶子，这里一个节点可能有两个孩子，我们可以采取假设法

//向下调整
void AdjustDown(HPDataType* a, int n, int parent)
{//先假设左孩子int child = parent * 2 + 1;while (child < n)//child >= n说明孩子不存在，调整到叶子了{//找出小的那个孩子if (child + 1 < n && a[child + 1] < a[child])//这里child+1是判断是否有右孩子{++child;}if (a[child] < a[parent]){Swap(&a[child], &a[parent]);parent = child;child = parent * 2 + 1;}else{break;}}
}

2.5 取堆顶数据、判空、返回元素个数

//取堆顶的数据
HPDataType HPTop(HP* php)
{return php->a[0];
}
// 堆的数据个数
int HPsize(HP* php)
{return php->size;
}
//堆的判空
bool HPEmpty(HP* php)
{assert(php);return php->size == 0;
}

过于简单，就不多赘述

2.6 测试代码

void TestHeap1()
{int a[] = {4,2,8,1,5,6,9,7};HP hp;HPInit(&hp);for (size_t i = 0; i < sizeof(a) / sizeof(int); i++){HPPush(&hp,a[i]);}int i = 0;while (!HPEmpty(&hp)){printf("%d ", HPTop(&hp));HPPop(&hp);}HPDestroy(&hp);
}

3.堆排序算法

我们知道，如果是小堆，那么我们堆顶的元素一定是最小的，我们把数据导入到一个堆中，然后通过不断的取堆顶的元素再删除，这样确实可以排序但是空间复杂度为O(N)，每次排序还需要建堆，这样太麻烦了。

其实我们还有一种办法，直接让数组变成堆，首先可以采取向上调整算法，从数组的第二个元素开始，依次向上调整，直至最后一个元素，这不就变成堆了，然后再利用堆顶数据进行最大或最小进行堆排序。

但是如果我们要排降序是建大堆还是建小堆呢？如果建大堆我们第一个数就是最大的数，那我们就不能动它了，这不意味着我们要把剩下的数据看成一个堆，再去选出最大的数，那这不就破坏了堆的性质，兄弟变父子了关系全乱了，这种方法也是可以的需要重新建堆但是代价太大了不建议，所以我们要建小堆，堆顶的数据就是最小的我们把它和最后一个元素交换然后删除（伪删除），然后向下调整，选出第二小的然后在和倒数第二个元素进行交换，在向下调整，直至排序完毕，从后往前排不就是降序了，时间复杂度为O(N*logN)

void TestHeap2()
{int a[] = { 4,2,8,1,5,6,9,7 };HeapSort(a, sizeof(a) / sizeof(int));
}
void HeapSort(int* a, int n)
{//降序 建小堆//升序 建大堆for (int i = 1; i < n; i++){AdjustUp(a, i);}//O(N*logN)int end = n - 1;while (end > 0){Swap(&a[0], &a[end]);AdjustDown(a, end, 0);--end;}
}

这里还有一种更优的算法叫向下调整建堆算法，需确保子树是堆，我们从倒数第一个非叶子节点进行向下调整，倒着往回调，这种向下调整算法时间复杂为O(N)

void TestHeap2()
{int a[] = { 4,2,8,1,5,6,9,7 };HeapSort(a, sizeof(a) / sizeof(int));
}
void HeapSort(int* a, int n)
{for (int i = (n - 1 - 1) / 2; i < n; i++){AdjustDown(a, n, i);}//O(N*logN)int end = n - 1;while (end > 0){Swap(&a[0], &a[end]);AdjustDown(a, end, 0);--end;}
}

4.TOP-K问题

TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。

比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。

对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能 数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决。

基本思路如下：

1. 用数据集合中前K个元素来建堆 前k个最大的元素，则建小堆 前k个最小的元素，则建大堆

2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素

将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。

举个例子：假设十万个数据里面求最大的前K个数，要求是只有1KB内存，这些数据在磁盘文件中。

首先我们建K个小堆，剩下的N-K个元素依次与堆顶元素进行比较，如果大于堆顶就替换，在向下调整，结束后堆中的数据就是前K个最大的数据了

我们先生成十万个随机值

void CreateNDate()
{//造数据int n = 100000;srand(time(0));const char* file = "data.txt";FILE* fin = fopen(file, "w");if (fin == NULL){perror("fopen error");return;}for (int i = 0; i < n; i++){int x = (rand() + i) % 10000000;fprintf(fin, "%d\n", x);}fclose(fin);
}

在读取文件中前K个数，然后建K个数的小堆，在依次读取剩下的N-K个数与堆顶比较。

void TestHeap3()
{int k;printf("请输入k>:");scanf("%d", &k);int* kminheap = (int*)malloc(sizeof(int) * k);if (kminheap == NULL){perror("malloc fail");return;}const char* file = "data.txt";FILE* fout = fopen(file, "r");if (fout == NULL){perror("fopen error");return;}//读取文件中前k个数for (int i = 0; i < k; i++){fscanf(fout, "%d", &kminheap[i]);}//建k个数的小堆for (int i = (k - 1 - 1) / 2; i >= 0; i--){AdjustDown(kminheap, k, i);}//读取剩下的N-k个数int x = 0;while (fscanf(fout, "%d", &x) > 0){if (x > kminheap[0]){kminheap[0] = x;AdjustDown(kminheap, k, 0);}}printf("最大前%d个数：", k);for (int i = 0; i < k; i++){printf("%d ", kminheap[i]);}printf("\n");
}

它的时间复杂度为 O(logK*(N-K))，用大O的渐进法表示为O(N) 

5.向上调整建堆和向下调整建堆的时间复杂度分析

我们先来看向下调整建堆的时间复杂度，因为堆是完全二叉树，而满二叉树也是完全二叉树，此处为了简化使用满二叉树来证明(时间复杂度本来看的 就是近似值，多几个结点不影响最终结果)：

由此可见我们向下调整建堆算法时间为O(N)

我们再来看一下向上调整算法的时间复杂度，证明如下：

由此可见我们向上调整建堆算法时间为O(N*logN)

向下调整建堆：节点数量多的层 * 调整次数少，节点数量少的层 * 调整次数多

向上调整建堆：节点数量多的层 * 调整次数多，节点数量少的层 * 调整次数少

总结

  1. 堆的实现：
    堆是一种特殊的树形数据结构，通常实现为完全二叉树。堆分为最大堆和最小堆，最大堆的父节点值大于或等于其子节点值，而最小堆的父节点值小于或等于其子节点值。堆通常使用数组来实现，通过索引关系模拟树形结构，支持高效的插入、删除和查找最大/最小元素操作。

  2. 堆排序：
    堆排序是一种基于堆的排序算法。首先构建一个最大堆（或最小堆），然后将堆顶元素（最大或最小元素）与堆尾元素交换，并调整剩余元素以保持堆的性质。接着减小堆的大小，重复上述步骤，直到堆中只剩下一个元素，此时数组已经有序。堆排序的时间复杂度为O(nlogn)，空间复杂度为O(1)。

  3. 向上调整算法和向下调整算法是堆数据结构和堆排序中的关键算法。它们通过比较和交换元素的位置来维持堆的性质，并确保堆始终满足其定义。这些算法在实现堆数据结构和堆排序时发挥着重要作用，并确保了这些数据结构和算法的高效性和正确性。

  4. TOP-K问题：
    TOP-K问题是指在大量数据中找出最大的K个元素或最小的K个元素。使用堆（特别是最小堆或最大堆）可以高效地解决TOP-K问题。首先维护一个大小为K的堆，遍历数据并将元素与堆顶元素比较，如果新元素比堆顶元素大（最大堆）或小（最小堆），则删除堆顶元素并将新元素插入堆中。遍历结束后，堆中剩余的K个元素即为所求的TOP-K元素。这种方法的时间复杂度与数据总量n和K相关，但通常远优于直接排序

这篇关于【数据结构】堆的实现和堆排序--TOP-K问题的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1082043。

相关文章

解决jupyterLab打开后出现Config option `template_path`not recognized by `ExporterCollapsibleHeadings`问题

解决jupyterLab打开后出现Config option `template_path`not recognized by `ExporterCollapsibleHeadings`问题

《解决jupyterLab打开后出现Configoption`template_path`notrecognizedby`ExporterCollapsibleHeadings`问题》在Ju... 目录jupyterLab打开后出现“templandroidate_path”相关问题这是 tensorflo
阅读更多...
如何解决Pycharm编辑内容时有光标的问题

如何解决Pycharm编辑内容时有光标的问题

《如何解决Pycharm编辑内容时有光标的问题》文章介绍了如何在PyCharm中配置VimEmulator插件,包括检查插件是否已安装、下载插件以及安装IdeaVim插件的步骤... 目录Pycharm编辑内容时有光标1.如果Vim Emulator前面有对勾2.www.chinasem.cn如果tools工
阅读更多...
Java深度学习库DJL实现Python的NumPy方式

Java深度学习库DJL实现Python的NumPy方式

《Java深度学习库DJL实现Python的NumPy方式》本文介绍了DJL库的背景和基本功能,包括NDArray的创建、数学运算、数据获取和设置等,同时,还展示了如何使用NDArray进行数据预处理... 目录1 NDArray 的背景介绍1.1 架构2 JavaDJL使用2.1 安装DJL2.2 基本操
阅读更多...
最长公共子序列问题的深度分析与Java实现方式

最长公共子序列问题的深度分析与Java实现方式

《最长公共子序列问题的深度分析与Java实现方式》本文详细介绍了最长公共子序列（LCS）问题,包括其概念、暴力解法、动态规划解法,并提供了Java代码实现,暴力解法虽然简单,但在大数据处理中效率较低,... 目录最长公共子序列问题概述问题理解与示例分析暴力解法思路与示例代码动态规划解法DP 表的构建与意义动
阅读更多...
Java多线程父线程向子线程传值问题及解决

Java多线程父线程向子线程传值问题及解决

《Java多线程父线程向子线程传值问题及解决》文章总结了5种解决父子之间数据传递困扰的解决方案,包括ThreadLocal+TaskDecorator、UserUtils、CustomTaskDeco... 目录1 背景2 ThreadLocal+TaskDecorator3 RequestContextH
阅读更多...
关于Spring @Bean 相同加载顺序不同结果不同的问题记录

关于Spring @Bean 相同加载顺序不同结果不同的问题记录

《关于Spring@Bean相同加载顺序不同结果不同的问题记录》本文主要探讨了在Spring5.1.3.RELEASE版本下,当有两个全注解类定义相同类型的Bean时,由于加载顺序不同,最终生成的... 目录问题说明测试输出1测试输出2@Bean注解的BeanDefiChina编程nition加入时机总结问题说明
阅读更多...
关于最长递增子序列问题概述

关于最长递增子序列问题概述

《关于最长递增子序列问题概述》本文详细介绍了最长递增子序列问题的定义及两种优化解法：贪心+二分查找和动态规划+状态压缩,贪心+二分查找时间复杂度为O(nlogn),通过维护一个有序的“尾巴”数组来高效... 一、最长递增子序列问题概述1. 问题定义给定一个整数序列，例如 nums = [10, 9, 2
阅读更多...
java父子线程之间实现共享传递数据

java父子线程之间实现共享传递数据

《java父子线程之间实现共享传递数据》本文介绍了Java中父子线程间共享传递数据的几种方法,包括ThreadLocal变量、并发集合和内存队列或消息队列,并提醒注意并发安全问题... 目录通过 ThreadLocal 变量共享数据通过并发集合共享数据通过内存队列或消息队列共享数据注意并发安全问题总结在 J
阅读更多...
Spring AI Alibaba接入大模型时的依赖问题小结

Spring AI Alibaba接入大模型时的依赖问题小结

《SpringAIAlibaba接入大模型时的依赖问题小结》文章介绍了如何在pom.xml文件中配置SpringAIAlibaba依赖,并提供了一个示例pom.xml文件,同时,建议将Maven仓... 目录（一）pom.XML文件：（二）application.yml配置文件（一）pom.xml文件：首
阅读更多...
SpringBoot+MyBatis-Flex配置ProxySQL的实现步骤

SpringBoot+MyBatis-Flex配置ProxySQL的实现步骤

《SpringBoot+MyBatis-Flex配置ProxySQL的实现步骤》本文主要介绍了SpringBoot+MyBatis-Flex配置ProxySQL的实现步骤,文中通过示例代码介绍的非常详... 目录 目标 步骤 1：确保 ProxySQL 和 mysql 主从同步已正确配置ProxySQL 的
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2