二叉树堆的建立与排序

在数据结构中，二叉树是非常好用的一种数据结构，这节暂时按下不表。这节课主要介绍堆的建立与使用。

堆，是二叉树中一种很特殊的结构，首先，他必须是满二叉树，也就是除了最后一层以外，其他层都是满的。

堆对于节点数据也有要求，其基本按照某种规律进行排序。首先堆分为大堆和小堆。大堆上大小大小堆上小下大。有非常大的差距。并且在堆中每个节点也满足完全二叉树的父子节点规律，既child=parent*2+1 | 2,1和2取决于是子左节点还是右节点。

堆的实现

typedef int HPDataType;
typedef struct Heap
{
	HPDataType* _a;
	int _size;
	int _capacity;
}Heap;//child = father*2+1 | 2;

一个堆的基本结构体如上图所示，它应该有一个特定类型的指针_a，一个代表堆目前数量的size，一个代表目前容量的_capacity。为什么选择顺序表作为建堆类型呢？首先是因为堆不需要在中间插入数据，他是满二叉树；第二是因为利用数组来建队可以发现数组的下标之间的关系，就是这个公式：child=parent*2+1 | 2，便于进行计算。本文前半部分基本以小堆为准。

堆的初始化

void HeapInit(Heap* php)
{
	assert(php);
	php->_a = NULL;
	php->_capacity = 0;
	php->_size = 0;
}//函数初始化

Heap* HeapKCreat(int k)
{
	Heap* hp = (Heap*)malloc(sizeof(Heap));
	if (hp == NULL)
	{
		perror("fail:hp creat");
		exit(1);
	}

	int* arr = (int*)malloc(sizeof(int) * k);
	hp->_a = arr;
	hp->_size = 0;
	hp->_capacity = 0;
	return hp;
}函数创建

堆的创建分为两种方式，一种是在外面申请空间，然后再函数内设置数据，一种是直接在函数内部完成一切，总体而言还是简单的把相关数据进行简单设置。

堆的销毁

void HeapDestory(Heap* hp)
{
	assert(hp);
	free(hp->_a);
	hp->_a = NULL;
	hp->_capacity = hp->_size = 0;
}

堆的销毁也较为简单，便是顺序表的销毁。其中有一个地方需要注意，便是需要先把数组给free掉。

堆的两种整理方式

void AdjustUp(HPDataType* obj, int child)
{
	int parent = (child - 1) / 2;
	while (obj[parent] > obj[child] && child > 0)
	{
		Swap(&obj[child], &obj[parent]);
		child = parent;
		parent = (child - 1) / 2;
	}
}

第一个函数是从下往上整理，先设置一个parent变量，这个变量便是孩子的父节点，因为/操作符的整除性，所以会自动得到对应节点。接着比较子节点大小与父节点大小的，若父节点大于子节点，那就父子对换，并让子为父，在重新设置父节点。一直到父节点不再大于子节点或者子节点到了顶部。

void AdjustDowm(HPDataType* obj, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (obj[child + 1] < obj[child] && child + 1 < n)
		{
			child++;
		}
		if (obj[parent] > obj[child])
		{
			Swap(&obj[child], &obj[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
			break;
	}
}

另一种方案是从上往下整理，同样的初始造个儿子操作。接着，判断儿子不要超过数组数据大小范围，这个设置出来的儿子是左儿子，接着判断右儿子和左儿子的大小关系.若是右儿子要大一些的话，那就让右儿子来和父节点较量较量。接着，若父节点大于子节点的话，那便换位置。一直到循环结束。

这两种方法总体而言方法二会更好一点，方法二的时间复杂度为O(logN),方法一为O(N).具体计算方法可以上b站查一下。

堆的数据增加

void HeapPush(Heap* hp, HPDataType x)
{
	assert(hp);
	if (hp->_capacity == hp->_size)
	{
		int newcapacity = hp->_capacity == 0 ? 4 : hp->_capacity * 2;
		HPDataType* b = (HPDataType*)realloc(hp->_a, newcapacity * sizeof(HPDataType));
		if (b == NULL)
		{
			exit(1);
		}
		hp->_a = b;
		hp->_capacity = newcapacity;
	}
	hp->_a[hp->_size] = x;
	hp->_size++;

	AdjustUp(hp->_a, hp->_size - 1);
}

堆的push首先断言一下，防止输入的结构体为空。接着，若此时容量等于当前数据量，那么会进入扩容阶段。此处建立一个一个newcapacity，利用三目操作符，如果此时容量大小为0，那么调整为4，若不是0，那么扩容两倍。接着realloc一个新的结构体指针，其大小便是调整后的新容量。接着在判断一下realloc是否成功，接着将realloc出来的指针给结构体中的_a指针，然后吧容量变为新的容量。接着就开始进行赋值，把数据x放在数组的最后一个空地址，接着将size++。再然后向上调整或者向下调整都是可以的。这里便选择了向上调整了。

堆的删除

void HeapPop(Heap* hp)
{
	assert(hp);
	assert(hp->_size > 0);
	Swap(&hp->_a[0], &hp->_a[hp->_size - 1]);

	hp->_size--;
	AdjustDowm(hp->_a, hp->_size, 0);

}

堆的删除首先要先确定不是空指针和堆里确实有数据。接着交换一下堆顶数据和堆底数据。将hp的size--，保证后续读取不到要删除的数据。接着将堆顶数据向下调整即可。

堆的部分简单判断与取数据

HPDataType HeapTop(Heap* hp)
{
	assert(hp);
	assert(hp->_size > 0);
	return hp->_a[0];
}//取堆顶数据

int HeapSize(Heap* hp)
{
	assert(hp);
	return hp->_size;
}取堆大小

int HeapEmpty(Heap* hp)
{
	assert(hp);
	return hp->_size == 0;
}判断堆是否空了

堆的排序

void HeapSort(int* a, int n)
{
	//for (int i = 0; i < n; i++)
	//{
	//	AdjustUp(a, a[i]);
	//}空间要求较多，建议从下往上整，既下面方案
	int end = n - 1;
	while (end--)//
	{
		Swap(&a[0], &a[end]);
		AdjustDowm(a, n, 0);

	}
}

说是堆的排序，但其实针对于任何混乱的数组，将他们整理成有序的堆。堆的排序分为两种方式，第一种方法是从上面的代码，但是其堆空间的要求较多，因此较为推荐下面的方法。

TopK问题

我们建堆是为了什么呢？建堆一个很重要的意义便是找出最大的几个数据或者最小的几个数据。一个很大的数据本，要求前k个最大的数据，可以通过什么方法呢？一个相对好用的方法就是通过建容量为k的小堆，然后逐渐替换堆内的数据来达成这个容量为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 (size_t i = 0; i < n; ++i)
	{
		int x = rand() % 1000000;
		fprintf(fin, "%d\n", x);
	}

	fclose(fin);
}

首先我们先来利用time的伪随机来创建一个数据库，内部包含10万个随机的数据，并将这些数据写入名字为data的txt文件，这就是我们后面用来举例的数据库了。

topk数据库

void PrintTopK(int k)
{
	int* arr = (int*)malloc(sizeof(int)*k);
	 char* file = "data.txt";
	 FILE* fin = fopen(file, "r");
	for (int i = 0; i < k; i++)
	{
		fscanf(fin, "%d ",&arr[i]);
	}
	int a = 0;
	while (fscanf(fin, "%d ", &a)!=EOF) 
	{
		if (a > arr[0])
		{
			arr[0] = a;
			AdjustDowm(arr,k,0);
		}
	}
	for (int i = 0; i < k; i++)
	{
		printf("%d ", arr[i]);
	}

}

首先，我们需要先创建出一个容量符合小堆的数组，因为我这里的数据都是整型，因此便直接使用int类型了。接着打开data文件，首先将data中前10个数据写入arr数组，接着设置一个普普通通的int类型数据a，接着进入while循环，fscanf会返回读到的数据数量，当没有数据的时候，则返回EOF，当还有数据的时候，将数据写入a中，判断a和arr[0]的大小关系。若arr[0]小于a，则将a写入数组中成为堆顶。接着向下调整刚刚写入的数据。直到已经将data文件中的数据全部读了一遍，此时数组中包含的数据便是所有的最大数据。接着将这些数据打印出来，便得到了TopK个数据了。