堆的应用：堆排序&TOP-K问题

前言

本节主要讲解堆的两个应用：堆排序和TOP-K问题。

一、堆排序

1、什么是堆排序

问题1： 堆排序是使用堆的结构，先将数据push入堆，再pop回数组吗？

不是，因为使用堆的结构排序会有两个问题：

• 麻烦，因为如果语言没有实现堆结构，就需要我们自己实现堆，例如C语言。
• 使用堆结构空间复杂度为O(N)

堆排序是利用堆的思想来排序，可分为两个步骤：

1. 建堆
   • 升序：建大堆
   • 降序：建小堆
2. 利用堆删除思想来进行排序

问题2： 怎样建堆？

我们可以使用向上调整和向下调整两种方式建堆。

1. 向上调整建堆：首先把数组第一个数据看作堆，然后把后面的数据按照数组顺序一个个向上调整，确保其满足堆的性质。（即模拟堆插入的过程）
2. 向下调整建堆：注意不能直接从根开始直接向下调整，因为向下调整的前提是左右子树必须都是大堆/小堆，所以是从倒数第一个叶子结点的父节点（即倒数第一个非叶子结点）开始向下调整，然后依次向前向上调整到根结点才结束。

问题3： 建堆有两种方式，那我们一般是选择哪种方式建堆？

我们一般使用向下调整来建堆 ，因为向下调整建堆的效率相比向上调整建堆更优。

1. 从直观角度上看，向下调整——结点多的向下移动的次数少，但向上调整——结点多的向上移动的次数多。
2. 向下调整时间复杂度为O(N)，向上调整时间复杂度为O(N*logN）。

问题4： 为什么升序建大堆，降序建小堆？

我们以升序建大堆为例讲解。

如果升序我们建小堆，虽然第一个数字就已经确定了，但是剩下的所有数据关系全乱了，只有重新建堆，即有n个数据我们就需要建堆n-1次，并且空间复杂度也还是0(N)，时间复杂度O(N^2*logN），那还不如使用其他方式排序。

tip：堆排序升序建大堆，降序建小堆。

2、堆排序的代码实现

HeapSort.h：

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

void Swap(int* e1, int* e2);

void AdjustUp(int* arr, int child);

void AdjustDown(int* arr, int n, int parent);

void Print(int* arr, int n);

void HeapSort(int* arr, int n);

HeapSort.c：

#include"HeapSort.h"

//交换
void Swap(int* e1, int* e2)
{
	int temp = *e1;
	*e1 = *e2;
	*e2 = temp;
}

//大堆的向上调整
void AdjustUp(int* arr, int child)
{
	assert(arr);
	int parent = (child - 1) / 2;
	//向上调整：到跟结束
	while (child > 0)
	{
		//特殊：当父亲大于孩子时结束循环
		if (arr[child] > arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			//迭代
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

//大堆的向下调整
void AdjustDown(int* arr, int n, int parent)
{
	assert(arr);
	//假设法：定义一个变量存储较大孩子的下标，先假设左孩子大
	int child = parent * 2 + 1;
	//向下调整：调整到叶子结束
	while (child < n)
	{
		//if确定假设是否成立
		//注意：要先判断右孩子是否为有效数据
		if (child + 1 < n && arr[child] < arr[child + 1])
		{
			++child;
		}
		//特殊：当父亲大于孩子时结束循环
		if (arr[child] > arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			//迭代
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

//打印数组
void Print(int* arr, int n)
{
	assert(arr);
	int i = 0;
	for (i = 0; i < n; ++i)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

//堆排序——排升序
void HeapSort(int* arr, int n)
{
	assert(arr);
	//1、建堆
	向上调整，时间复杂度0(N*logN)
	//int i = 1;
	//for (i = 1; i < n; ++i)
	//{
	//	AdjustUp(arr, i);
	//}

	//向下调整，时间复杂度0(N)
	int i = (n - 1 - 1) / 2;//倒数第一个非叶子，即倒数第一个叶子的父亲，(所以第一个-1是下标从0开始)
	for (i = (n - 2) / 2; i >= 0; --i)
	{
		AdjustDown(arr, n, i);
	}

	//2、利用堆删除思想来进行排序，时间复杂度0(N*logN)
	int end = n - 1;//最后一个数据的下标
	while (end > 0)
	{
		Swap(&arr[0], &arr[end]);
		AdjustDown(arr, end, 0);//end等于数组前面的数据个数
		//迭代
		--end;
	}
}

test.c：

#include"HeapSort.h"

int main()
{
	int arr[] = { 8,5,3,6,4,7,2,1,0 };
	int size = sizeof(arr) / sizeof(arr[0]);
	HeapSort(arr, size);
	Print(arr, size);
	return 0;
}

二、TOP-K问题

1、什么是TOP-K问题

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

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

问题： 找N个数中最大的前K个数，我们是直接建N个数据的大堆，再pop K次吗？

不是，因为TOP-K问题一般数据量都比较大。

假设N很大，比如在100亿个整数里面找出最大的前10个数。此时上面的方法就不能用了，因为内存存不下100亿个数，数据在磁盘中。

tip：

• 1G = 1024MB = 10241024KB = 10241024*1024byte ≈ 10亿字节
• 一个整数4个字节，100亿个整数约400亿个字节（小于），约40G。

使用堆的思想解决TOP-K问题的基本思路：

1. 用数据集合中前K个元素来建堆
   • 求前K个最大的元素，则建小堆（如果建大堆，假设堆顶元素就是N个元素中最大的，但剩余的N-K个元素有属于前K个的元素也不能进堆，不能解决问题）
   • 求前K个最小的元素，则建大堆
2. 遍历剩余的N-K个元素依次与堆顶来比较
   • 求前K个最大的元素：如果这个元素大于堆顶元素，则替换堆顶，并向下调整，最后这个小堆的数据就是最大的前K个
   • 求前K个最小的元素：如果这个元素小于堆顶元素，则替换堆顶，并向下调整，最后这个大堆的数据就是最小的前K个

2、TOP-K的代码实现

//小堆的向下调整
void AdjustDown(int* arr, int n, int parent)
{
	assert(arr);
	//假设法：定义一个变量存储较小孩子的下标，先假设左孩子小
	int child = parent * 2 + 1;
	//向下调整：调整到叶子结束
	while (child < n)
	{
		//if确定假设是否成立
		//注意：要先判断右孩子是否为有效数据
		if (child + 1 < n && arr[child] > arr[child + 1])
		{
			++child;
		}
		//特殊：当父亲小于孩子时结束循环
		if (arr[child] < arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			//迭代
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void PrintTopK(const char* file, int k)
{
	// 1. 建堆--用a中前k个元素建小堆
	int* topk = (int*)malloc(sizeof(int) * k);
	assert(topk);

	FILE* fout = fopen(file, "r");
	if (fout == NULL)
	{
		perror("fopen error");
		return;
	}

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

	for (int i = (k - 2) / 2; i >= 0; --i)
	{
		AdjustDown(topk, k, i);
	}

	// 2. 将剩余n-k个元素依次与堆顶元素比较
	int val = 0;
	int ret = fscanf(fout, "%d", &val);//失败返回EOF
	while (ret != EOF)
	{
		//如果这个元素大于堆顶元素，则替换堆顶，并向下调整
		if (val > topk[0])
		{
			topk[0] = val;
			AdjustDown(topk, k, 0);
		}
		//迭代
		ret = fscanf(fout, "%d", &val);
	}
	//最后这个小堆的数据就是最大的前K个
	Print(topk, k);

	free(topk);
	fclose(fout);
}

void CreateNDate()
{
	// 造数据
	int n = 10000000;
	srand((unsigned int)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() % 10000;//生成0~10000的随机数
		fprintf(fin, "%d\n", x);
	}

	fclose(fin);
}

int main()
{
	//CreateNDate();//只运行一次，之后在文件中自己改10个最大的数据
	PrintTopK("data.txt", 10);

	return 0;
}

总结：不管是堆排序还是TOP-K问题，其本质都是在利用堆的性质在选数