数据结构堆（Heap）的实现

数据结构堆（Heap）的实现

堆的概念

如果有一个关键码的集合K = { ， ， ，…， }，把它的所有元素按完全二叉树的顺序存储方式存储
在一个一维数组中，并满足： <= 且 <= ( >= 且 >= ) i = 0，1，2…，则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

• 小堆的示例

• 大堆的示例
  

堆的性质：

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

堆的向上调整算法

当我们在一个堆的末尾插入一个数据后，需要对堆进行调整，使其仍然是一个堆，这时需要用到堆的向上调整算法。

向上调整思想（建小堆）
1.将插入结点与其父结点比较。
2. 若插入结点的值比其父结点的值小，则交换插入结点与其父结点的位置，并将原目标结点的父结点当作新的目标结点继续进行向上调整。若插入结点的值比其父结点的值大，则停止向上调整，此时该树已经是小堆了。

代码实现如下：

void Swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}
void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			//HPDataType t = a[parent];
			//a[parent] = a[child];
			//a[child] = t;

			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

堆的向下调整算法

现在我们给出一个数组，逻辑上看做一颗完全二叉树。我们通过从根节点开始的向下调整算法可以把它调整成一个小堆。向下调整算法有一个前提：左右子树必须是一个堆，才能调整。
若想将其调整为小堆，那么根结点的左右子树必须都为小堆。
若想将其调整为大堆，那么根结点的左右子树必须都为大堆。

向下调整思想（建小堆）

• 从根节点处开始，选出其左右孩子中值较小的孩子节点；
• 让较小的孩子与父亲进行比较；
  1）.若较小的孩子比父亲还小，则该孩子与其父亲的位置进行交换。并将原来较小的孩子的位置当成父亲继续向下进行调整，直到调整到叶子结点为止。
  2）.若较小的孩子比父亲大，则不需处理了，调整完成，整个树已经是小堆了。

代码实现如下：

void Swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}
堆的向下调整（小堆）
void AdjustDown(int* a, int n, int parent)
{
	int child = parent * 2 + 1;//假设其左孩子的值较小
	while (child < n)
	{
		if (child + 1 < n
			&&a[child + 1] > a[child])//右孩子存在并且右孩子比左孩子还小
		{
			++child;
		}

		if (a[child] < a[parent])//左右孩子中较小孩子的值比父结点还小
		{
			//将父结点与较小的子结点交换
			Swap(&a[child], &a[parent]);
			//继续向下进行调整
			parent = child;
			child = 2 * parent + 1;
		}
		else//成堆
		{
			break;
		}
	}
}

使用堆的向下调整算法，最坏的情况下（即一直需要交换结点），需要循环的次数为：h - 1次（h为树的高度）。而h = log(N+1）。所以堆的向下调整算法的时间复杂度为：O(logN) 。

因为在使用向下调整算法时，我们首先需要得到一个堆，那对于任意一棵树，我们如何将其调整为堆呢？
我们只需要从倒数第一个非叶子结点开始，从后往前，按下标，依次作为根去向下调整即可。

代码实现如下：

//建堆
for (int i = (n - 1 - 1) / 2; i >= 0; i--)
{
	AdjustDown(php->a, php->size, i);
}

总结：
堆的向下调整算法的时间复杂度：T ( n ) = O ( log ⁡ N )
建堆的时间复杂度：T ( n ) = O ( N )

堆的实现

堆的初始化

首先，必须创建一个堆类型，该类型中需包含堆的基本信息：存储数据的数组、堆中元素的个数以及当前堆的最大容量。

typedef int HPDataType;
typedef struct Heap
{
	HPDataType* a;
	int size;
	int capacity;
}HP;
void HeapInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->capacity = php->size = 0;
}

堆的销毁

void HeapDestroy(HP* php)
{
	assert(php);

	free(php->a);
	php->a = NULL;
	php->capacity = php->capacity = 0;
}

堆的插入

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

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

	}

	php->a[php->size] = x;
	php->size++;
	AdjustUp(php->a, php->size - 1);
}

堆的删除（堆顶元素）

void HeapPop(HP* php)
{
	assert(php);
	assert(!HeapEmpty(php));

	Swap(&php->a[0], &php->a[php->size - 1]);
	php->size--;

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

堆顶元素的获取

HPDataType HeapTop(HP* php)
{
	assert(php);
	assert(!HeapEmpty(php));
	
	return php->a[0];
}

堆的判空

bool HeapEmpty(HP* php)
{
	assert(php);

	return php->size == 0;
}

堆数据个数的获取

int HeapSize(HP* php)
{
	assert(php);

	return php->size;
}