手把手带你实现堆

目录

什么是堆？

---

什么是堆？

上一篇文章我们讲到了二叉树，还分析了满二叉树和完全二叉树，而堆就是完全二叉树，例如这样子的就是一个堆，还是很好理解的。

堆用什么来实现？

堆他是一个有规律的数据结构，除了叶子，他的每个节点都要满足两个子节点。所以我们将用数组来实现它。本篇以小堆为例。

堆的实现接口

在实现它之前，我们得拿到接口，才知道我们应该怎么去实现，有一个大致的方向。接口如下，如果看完这篇文章，想要自己实现一遍，就可以复制这些接口，可以很好的检测自己的掌握情况。

//初始化
void HeapInit(HP* hp);
// 堆的销毁
void HeapDestory(HP* hp);
// 堆的插入
void HeapPush(HP* hp, HPDataType x);
// 堆的删除
void HeapPop(HP* hp);
// 取堆顶的数据
HPDataType HeapTop(HP* hp);
// 堆的数据个数
int HeapSize(HP* hp);
// 堆的判空
bool HeapEmpty(HP* hp);

准备工作

堆的本质其实就是数组，所以我们只要创建数组就行了，比以前写的要简单很多，这里我就不过多赘述了。咱们看代码。

#pragma once

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>

typedef int HPDataType;

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

}HP;

逐一分解

1.初始化

一直都很简单的一个步骤，这里就不多说了。

//初始化
void HeapInit(HP* hp)
{
	assert(hp);

	hp->a = NULL;
	hp->capacity = 0;
	hp->size = 0;

}

2.堆的销毁

和初始化差不多，看代码。

// 堆的销毁
void HeapDestory(HP* hp)
{
	assert(hp);
	free(hp);
	hp->a = NULL;
	hp->capacity = 0;
	hp->size = 0;

}

3.重头戏：堆的插入

我们知道堆的本质是数组，那么想要插入数据，就只能往最后插入，这样就不用去移动别的数据，是最佳方案。但是，我们是要实现小堆，子节点必须比父节点大，所以我们要进行调整，怎么调整？在哪里调整？插入进来的数我们也不知道有多大，该插入到哪里？就像下面这个堆，没有标记数字的是我们想要插入的数据，如果我插入

的是小数字呢？这个时候有一个解决方法，就是将他和祖先比较，如果他和父亲比较是他小的话，那他们就交换位置，如果不是就停在那个位置，就满足了小堆的规则，什么时候停下来呢，就是能和根比较的话，就是当他的下标小于0时。还有一个问题要解决，就是怎么找到他的父节点。如果看过我前面那一篇文章的话，应该就知道，找到父节点，就减一除以二。大概思路都清楚了，我们看代码。

//交换
void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = 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]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;

		}
	}
}

这是向上调整函数。

// 堆的插入
void HeapPush(HP* hp, HPDataType x)
{
	assert(hp);
	if (hp->capacity == hp->size)
	{
		int newcapacity = hp->capacity == 0 ? 4 : 2 * hp->capacity;
		HPDataType* tmp = (HPDataType*)realloc(hp->a,sizeof(HPDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail!");
			return;
		}
		hp->a = tmp;
		hp->capacity = newcapacity;

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

}

4.重头戏：堆的删除 

 其实和堆的插入也大差不差，但是堆的删除是删除的堆顶。那如果就这样删除可得话，我们节点的顺序会乱套的，所以，我们将根和最后一个叶节点交换一下，然后向下调整。其实也和上面差不多。看代码。

//向下删除
void AdjustDown(HPDataType* 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[parent] > a[child])
		{
			Swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;

		}
	}
	
}

这是向下删除的函数。

// 堆的删除
void HeapPop(HP* hp)
{
	//删除的是堆的顶,我们将最后一个和堆顶交换一下，然后将size--，这样堆顶删除了，但是还要我们向下调整一下。
	assert(hp);
	assert(hp->size > 0);

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


}

这是堆的删除的函数。

5.取堆顶的数据 

 这个很简单，直接返回就行了。

// 取堆顶的数据
HPDataType HeapTop(HP* hp)
{
	assert(hp);
	assert(hp->size > 0);
	return hp->a[0];

}

 6.堆的数据个数

// 堆的数据个数
int HeapSize(HP* hp)
{
	assert(hp);
	return hp->size;

}

 7.堆的判空

// 堆的判空
bool HeapEmpty(HP* hp)
{
	assert(hp);
	return hp->size == 0;

}

这就完成了，整个堆的实现。如果想要测试一下的话，测试代码贴下面了。

#include "Heap.h"


void test01()
{
	int a[] = { 3,5,4,6,9,8,7,1,2 };
	HP hp;
	HeapInit(&hp);
	for (size_t i = 1; i < sizeof(a) / sizeof(a[0]); i++)
	{
		HeapPush(&hp, a[i]);

	}

	while (!HeapEmpty(&hp))
	{
		printf("%d ", HeapTop(&hp));
		HeapPop(&hp);

	}
}

int main()
{
	test01();

	return 0;
}

这就是整个堆的实现了，是不是很简单？