二叉树建堆及Topk问题

我们知道二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构。

建堆的过程就是在顺序结构上存储的，顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费。而现实中使用中只有堆才会使用数组来存储二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。

 1.堆的概念及结构

我们将元素以二叉树的结构存入数组中，将根结点最大的堆叫做最大堆或大根堆，根结点最小的堆叫做最小堆或小根堆。

堆是一颗完全二叉树

2.堆的实现

2.1 堆的初始化

typedef int HPDataType;

typedef struct Heap
{
	HPDataType* a;
	int size;
	int capacity;
}HP;


void HPInit(HP* php) //初始化
{
	php->a = (HPDataType*)malloc(sizeof(HPDataType) * 4);
	if (php->a == NULL)
	{
		perror("malloc fail");
		return;
	}
	php->capacity = 4;
	php->size = 0;
}

 这是堆的结构定义及初始化，我们开辟一块数组空间来存放具有二叉树结构的数据。

2.2堆的数据插入

void HPPush(HP* php,HPDataType x) //插入数据
{
	assert(php);
	if (php->size == php->capacity)
	{
		HPDataType* tmp = (HPDataType*)realloc(php->a,sizeof(HPDataType) * php->capacity * 2);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		php->capacity *= 2;
		php->a = tmp;

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

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

如果空间不够我们就扩容，在这里我们插入数据时，是将数据放入数组的最后，然后用向上调整法来排入数据。

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;
		}
		
	}

}

我们知道在二叉树中 parent=（child-1）/2  ;  child=parent*2+1或者child=parent*2+2

这是父节点与左右孩子的关系，因为实现的是创建大根堆，在向上调整法中只要孩子比父亲大，就可以互换位置，不断调整，实现大堆。

2.3堆的数据删除

void HPPop(HP* php)
{
	assert(php);
	assert(!HPEmpty(php));
	swap(&php->a[0], &php->a[php->size - 1]);
	php->size--;
	AdjustDown(php->a, php->size, 0);
}

在删除数据中，我们需要将堆顶的数据删除掉，所以我们将堆顶的数据与最后一个节点的数据相互交换。删除最后一个数据，使用向下调整法，将小的数据调整到合适的位置。

void AdjustDown(HPDataType *a,int size,int parent) //向下调整法 
{
	int child = parent * 2 + 1;
	while (child < size)
	{
		if (child + 1 < size && a[child + 1] > a[child])//找出最大的孩子
		{
			child++;
		}
		if (a[child] > a[parent])
		{
			swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}

	}
}

3.使用堆来排序（堆排序）

void AdjustDown(HPDataType *a,int size,int parent) //向下调整法 
{
	int child = parent * 2 + 1;
	while (child < size)
	{
		if (child + 1 < size && a[child + 1] > a[child])//找出最大的孩子
		{
			child++;
		}
		if (a[child] < a[parent])
		{
			swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}

	}
}


void HeapSort(int* a, int n)
{
	
	// 建堆 -- 向下调整建堆 -- O(N)
	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDown(a, n, i);
	}

	// 自己先实现 -- O(N*logN)
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[end], &a[0]);
		AdjustDown(a, end, 0);

		--end;
	}
}

这里是使用堆排序来排一个升序，我们需要将二叉树的倒数第二层的父节点开始向下调整，使传入的数组，可以排成一个大根堆，然后使用向下调整法，来调整排序。

4.TopK问题

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

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

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

1. 用数据集合中前K个元素来建堆

   • 前k个最大的元素，则建小堆

   • 前k个最小的元素，则建大堆

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

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

4.1创造数据

void CreateNDate()
{
	// 造数据
	int n = 10000000;
	srand(time(0));
	const char* file = "data.txt";
	FILE* fin = fopen(file, "w");
	if (fin == NULL)
	{
		perror("fopen error");
		return;
	}

	for (size_t i = 0; i < n; ++i)
	{
		int x = rand() % 10000;
		fprintf(fin, "%d\n", x);
	}

	fclose(fin);
}

4.2Topk实现

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);
	while (ret != EOF)
	{
		if (val > topk[0])
		{
			topk[0] = val;
			AdjustDown(topk, k, 0);
		}

		ret = fscanf(fout, "%d", &val);
	}

	for (int i = 0; i < k; i++)
	{
		printf("%d ", topk[i]);
	}
	printf("\n");

	free(topk);
	fclose(fout);
}