暴力数据结构之二叉树（堆的相关知识）

1. 堆的基本了解

        堆（heap）是计算机科学中一种特殊的数据结构，通常被视为一个完全二叉树，并且可以用数组来存储。堆的主要应用是在一组变化频繁（增删查改的频率较高）的数据集中查找最值。堆分为大根堆和小根堆，大根堆中任意节点的值都大于其子树中节点的值，而小根堆则相反。堆的存储方式遵循层序遍历的规则，这样可以高效地利用存储空间。在数组中，根节点的下标为0，节点的左右孩子的下标可以通过特定的公式计算得出。堆的实现通常利用动态数组，这样可以快速扩展容量而不造成空间浪费。

堆的一些性质：1.堆中某个结点的值总是不大于或不小于其父结点的值；

                         2.堆总是一棵完全二叉树。

2. 堆的实现

 我们知道堆的逻辑结构是一个完全二叉树，但是其物理结构仍然是一个数组，所以实现堆创建一个数组即可。

typedef int HPDateType;
 
typedef struct Heap
{
	HPDateType* a;
	int size;
	int capacity;
}HP;
 
void HPInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->capacity = php->size = 0;
}
void HPDesTroy(HP* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->capacity = php->size = 0;
}
 
void Swap(HPDateType* p1, HPDateType* p2)
{
	HPDateType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
 
void AdjustUp(HPDateType* a, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[child]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}
 
void HPPush(HP* php, HPDateType x)
{
	if (php->capacity == php->size)
	{
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDateType* tmp = (HPDateType*)realloc(php->a, sizeof(HPDateType) * newcapacity);
		if (tmp = NULL)
		{
			perror("realloc");
			return;
		}
		php->a = tmp;
		php->capacity = newcapacity;
	}
 
	php->a[php->size] = x;
	php->size++;
 
	AdjustUp(php->a, php->size - 1);
}
void AdjustDown(HPDateType* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && a[child] > a[child + 1])
		{
			child++;
		}
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
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);
}
 
HPDateType HPTop(HP* php)
{
	assert(php);
	assert(php->size > 0);
 
	return php->a[0];
}
bool HPEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}

2.1 堆的插入

大堆的父节点均大于子节点，小堆恰好相反，自然实现逻辑各不相同，这里主要有两个主要的思想就是"父子值交换"，"父子址交换"。解释就是（以小堆为例）：

如果对一个已有的小堆插入新的数据（叶子），如果这个叶子与他的父节点相比更小，就与父节点交换，再与交换后节点所属的父节点对比，如果还是小于就继续交换。

 代码解释如下： 

当要插入数据时先将其放在叶子节点（数组尾部），通过AdjustUp函数可以实现向上比较的动作，当然插入前判断空间是否充足，适当扩容即可。

void AdjustUp(HPDateType* a, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[child]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}
 
void HPPush(HP* php, HPDateType x)
{
	if (php->capacity == php->size)
	{
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDateType* tmp = (HPDateType*)realloc(php->a, sizeof(HPDateType) * newcapacity);
		if (tmp = NULL)
		{
			perror("realloc");
			return;
		}
		php->a = tmp;
		php->capacity = newcapacity;
	}
 
	php->a[php->size] = x;
	php->size++;
 
	AdjustUp(php->a, php->size - 1);
}

2.2 堆的删除

堆的删除就是将根节点与叶子节点交换后直接删除交换后的叶子节点（即最初的跟节点数据），然后将交换后的根节点逐渐向下交换，如图所示：

 通过代码展示就是，先交换根节点与叶子结点（即数组头尾交换）然后直接删除交换后的叶子结点。创建一个AdjustDown函数，逐层下沉交换后的跟节点，保持仍然是一个堆。

void AdjustDown(HPDateType* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && a[child] > a[child + 1])
		{
			child++;
		}
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
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);
}

3.堆排序

主要思路：升序建大堆，降序建小堆

解释：以升序为例，创建一个大堆，即根节点为最大的数据，此时要排序，就直接将根节点与叶子结点交换（数组首尾交换），然后数组末尾的下标向前移动（此时数组末尾的数据不会参与后续运算），然后将交换后的跟节点使用AdjustDown函数下沉，以此类推，最后原数组就是一个升序排列。同理小堆也是如此。

为什么升序不用小堆呢，因为小堆每一次运算都要再次创建一个数组，浪费更多的内存，可以使用但是不推荐。同理这也是为什么降序使用小堆。

具体代码如下

void HeapSort(int* a, int n)
{
	// 降序，建小堆
	// 升序，建大堆
	for (int i = 1; i < n; i++)
	{
		AdjustUp(a, i);
	}
 
	
 
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;
	}
}