数据结构：手撕图解堆的实现和TopK的应用

重要的概念

要讲到堆，先要说两个关于二叉树的概念

1. 满二叉树：一个二叉树如果每一层的节点数都是最大值，那么这个二叉树就是满二叉树
   

2. 完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是满二叉树的变形，对于深度为k的树有n个节点的二叉树，当且仅当其每一个节点都与深度为k的满二叉树中编号从1至n的节点
   
   上面所展示的就是满二叉树和完全二叉树

树的存储方式

顺序存储

任何一个数据结构在内存中都要以一定的方式存储起来，那么具体如何存储起来？有下面的规则

首先是顺序存储，也就是用顺序表的形式存储，存储形式如下：

但很明显，这样的存储对于非完全二叉树来说会造成十分严重的内存浪费

链式存储

链式存储相比起顺序存储各有优势，链式存储的规则如下：

定义一个结构体，结构体中包含这三个成员，这三个成员就可以包含一个树的所有信息

下面重点介绍的是二叉树的顺序结构是如何实现的

堆的概念

首先要明确，这里的堆和malloc的堆并不是一个意思，前者的意思是一种数据结构，而后者是操作系统的一部分区域

堆是一种完全二叉树，它满足下面的性质

堆中某个节点的值总是不大于或不小于其父节点的值
堆总是一棵完全二叉树

那为什么是不大于或不小于？因为堆也是有划分的，堆分为大堆和小堆

在介绍大堆和小堆之前，先说明堆的顺序存储是如何存储的，以下面这个图为例

上图是一个完全二叉树，其中二叉树的父亲节点总是小于孩子节点，那么这就是小堆，而在内存中的存储形式如下图所示，存储的时候确实是按照数组存储，顺序遵循由上到下由左到右的顺序进行存储

大堆和上图基本一致，之时父亲节点总是大于孩子节点

堆的实现

那么作为一种数据结构，它会有它自己的用途，下面分析堆是如何实现的

从上述的存储结构可以看出，实际上每一个数组都可以把它看成是一个二叉树，由于堆的特殊性，首要问题就是如何把一个数组中的数字排序满足堆的要求

向上调整算法

这个算法主要是用来进行堆中元素的插入，当插入一个元素，由于大堆/小堆，这个插入的元素可能不符合堆的要求，这时候就需要用到向上调整算法

该算法的应用场景就是当一个元素要插入一个堆时，可以用这个算法进行插入，使得后续的二叉树依旧是堆，前提是插入前的二叉树必须满足堆的要求

该算法的流程是这样的

首先，原本有一个堆，有一个新元素12要插入这个堆中，它的位置应该是作为15的孩子节点，但由于小堆的规则，12小于15，因此这里的12应该和15交换一下位置，接着12再和它的上一代比较，发现12小于10，满足小堆的规则，因此新堆就变成了右图所示的模样，至此就完成了堆的插入

这里不得不提的是，插入的元素要进行向上调整算法的最终目标是它的祖先，只要它和上一代之间不满足规则，就一直交换，直到它成为了它所在的这一代的祖先为止

一些实现过程中的技巧

知道了孩子节点的序号如何求父节点？

由于计算机除号的取整性，父亲节点 == ( 孩子节点-1 ) / 2

实现搭建堆

根据上面的两个步骤，我们就可以开始搭建堆了

首先是把数组插入到堆中

int main()
{
	HP hp;
	HeapInit(&hp);
	int arr[] = { 9,8,6,5,43,2,1 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i < sz; i++)
	{
		HeapPush(&hp, arr[i]);
	}

	return 0;
}

这里假设直接插入，没有进行任何算法调位，那么结果应该是这样的

如果用向上调整算法进行调整，后面的结果是这样的

void Swap(HPDataType* child, HPDataType* parent)
{
	HPDataType tmp;
	tmp = *child;
	*child = *parent;
	*parent = tmp;
}

void AdjustUp(HP* php, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (php->a[child] < php->a[parent])
		{
			Swap(&php->a[child], &php->a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

void HeapPush(HP* php, HPDataType x)
{
	assert(php);

	if (php->size == php->capacity)
	{
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		php->a = (HPDataType*)malloc(sizeof(HPDataType) * newcapacity);
		if (php->a == NULL)
		{
			perror("malloc fail");
			return;
		}
	}

	php->a[php->size] = x;
	php->size++;

	AdjustUp(php, php->size - 1);
}

从中可以看出，这样的算法是可以进行堆正确排序的，这样，堆就搭建起来了

下面我们进行堆相关的其他操作

实现出堆的操作

有数据入堆就少不了出堆，那么数据是如何出堆的？

首先要明确是谁出堆，初学可能会认为是堆的最后一个元素，事实上，这样的操作是没有意义的，因此这里出堆，出的是堆顶的元素，那么问题就来了，如何实现出堆的功能？

如果你不加思考去想，这个功能很简单，直接把数组后面的内容覆盖不就好了吗？事实上，这样的想法是错误的，原因在于覆盖后的堆还能维持原来的现状吗？原来的父子关系会变成兄弟关系，原来的兄弟关系也会因为少了一个元素而发生改变，这整个过程会有很大变化，因此，这里引入了第二个算法，向下调整算法

这个算法设计也是很巧妙，假设我们现在搭建的是小堆，那么堆顶的元素是最小元素，现在我们让堆顶这个最小元素和整个堆的最后一个元素互换位置，那么此时堆顶元素变成另外一个元素，但是堆的其他部分依旧符合小堆的规则(交换的原来的最小值堆顶就不计入堆中了，已经被pop掉了)，那么接着就可以采用向下调整算法，让这个新的堆顶元素向下调整，这样就能实现目标

下面的图可以很好的解释这个原理

那么现在就要搞清楚什么是向下调整算法

向下调整算法

首先声明这个算法的使用条件，该算法适用于除了堆顶外的其他部分都满足小堆或大堆的条件时，可以使用，简单来说就是pop堆顶的时候可以使用

使用的原理也相当简单，假设我们这里是小堆，那么堆顶元素被弹出，此时堆中第二小的元素一定是这个堆顶元素的儿子，那么我们就让堆的最后一个叶子来充当这个新的堆顶，这样可以在保持堆整体的构造不变的前提下还能把堆顶元素弹出，紧接着就让这个堆顶元素和下面的儿子进行比较，谁小谁就是新的堆顶，进行交换后第二小的元素就产生了，当然，如果树的高度很高，那么交换后可能需要继续交换，知道这个叶子回到最后一层，这个过程也是可以借助循环实现的，借助这个向下调整算法就可以把堆顶元素弹出的同时还能变成一个新堆，不断的找出最小的值或最大的值

那么下面我们来实现这个算法

void AdjustDown(HP* php, int n, int parent)
{
	assert(php);
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && php->a[child + 1] < php->a[child])
		{
			child++;
		}
		if (php->a[child] < php->a[parent])
		{
			Swap(&php->a[child], &php->a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void HeapPop(HP* php)
{
	assert(php);
	Swap(&php->a[0], &php->a[php->size - 1]);
	php->size--;

	AdjustDown(php, php->size, 0);
}

堆排序

下面说明堆的另外一个作用，可以用来堆排序

首先说明堆排序的原理：假设现在这里有10个数字，现在把这10个数字建成小堆，那么堆顶的元素就是这10个数字的最小值，再让该数字和最后一个元素呼唤位置，这样最小值就到了最后一个位置，再进行向下调整算法可以调整出第二小的元素，按照上方的流程重新来一次，就能弄出新的数字，这样下去就可以实现降序排列的功能

具体操作流程如下

void HeapSort(HPDataType* a, int size)
{
	assert(a);

	//建堆
	for (int i = (size - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, size, i);
	}
	
	//排序
	int end = size - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		end--;
	}
}

这样的排序也是有效的

那么堆排序好在哪里？从时间复杂度来看，堆排序的时间复杂度只有O(NlogN)，整体来看效率还是可以的

TopK

堆真正强大的功能其实是强大在从很大一个量级的数字中要找出其中最大或最小的10个，假设这个数字是一亿甚至十亿，那么如果我们还采用的是正常的排序来看，那么整个过程就会相当麻烦，把这些数字全部排序再找最大或最小的几个，这个过程消耗的时间和空间复杂度是不可计算的，甚至计算机没有足够的内存供你建立如此庞大的空间

因此堆可以很好的解决这个问题，堆的功能主要体现在它可以筛选出你要的数据，下面介绍topk的原理

假设我们现在有10000个数字，我们要从中找到最大的5个，那么如何用堆来进行实现？
首先，我们把前五个数字建一个堆，假设我们要找的是最大的五个数，那么我们就建立小堆，然后让后面的数字依次从堆顶看能不能进入堆中，假设这个数字大于堆顶元素，那么就让这个元素称为堆顶元素，再进行向下调整，接着让下一个元素和堆顶比较…

按这样的想法实施下来，就可以使得堆中的元素是所有数字里面最大的五个元素，这样就能实现目标

下面就来模拟实现这个过程

首先，我们要获取到这10000个数据，下面展示获取数据量的一种途径

void CreateData()
{
	int n = 10000;
	srand(time(0));
	FILE* pf = fopen("test.txt", "w");
	if (pf == NULL)
	{
		perror("fopen fail");
		return;
	}
	for (int i = 0; i < n; i++)
	{
		int x = rand() % 10000;
		fprintf(pf, "%d\n", x);
	}
	fclose(pf);
}

获取了信息下面开始实现topk的功能

void PrintTopK()
{
	Heap hp = { 0,0,0 };
	HeapCreate(&hp,hp.a,4);
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		perror("fopen fail");
		return;
	}
	int* kmaxheap = (int*)malloc(sizeof(int) * 5);
	if (kmaxheap == NULL)
	{
		perror("malloc fail");
		return;
	}
	for (int i = 0; i < 5; i++)
	{
		fscanf(pf, "%d", &kmaxheap[i]);
		HeapPush(&hp, kmaxheap[i]);
	}
	int val = 0;
	while (!feof(pf))
	{
		fscanf(pf, "%d", &val);
		if (val > kmaxheap[0])
		{
			kmaxheap[0] = val;
			AdjustDown(kmaxheap, 5, 0);
		}
	}
	for (int i = 0; i < 5; i++)
	{
		printf("%d ", kmaxheap[i]);
	}
}