【数据结构】堆的实现和堆排序--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相关，但通常远优于直接排序