一、树的重要知识点

节点的度：一个节点含有的子树的个数称为该节点的度（有几个孩子）
叶节点或终端节点:度为0的节点称为叶节点；如上图：B、C、H、I...等节点为叶节点（0个孩子）
非终端节点或分支节点：度不为0的节点； 如上图：D、E、F、G...等节点为分支节点
父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点； 上图：A是B的父节点
孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点； 上图：B是A的孩子节点
兄弟节点：具有相同父节点的节点互称为兄弟节点； 如上图：B、C是兄弟节点(亲兄弟)
树的度：一棵树中，最大的节点的度称为树的度； 如上图：树的度为6（最多有几个孩子）
节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
树的高度或深度：树中节点的最大层次； 如上图：树的高度为4（H表示，从1开始）
堂兄弟节点：双亲在同一层的节点互为堂兄弟；如上图：H、I互为兄弟节点
节点的祖先：从根到该节点所经分支上的所有节点；如上图：A是所有节点的祖先
子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如上图：所有节点都是A的子孙
森林：由m（m>0）棵互不相交的树的集合称为森林；

二、二叉树

二叉树的度，孩子最多为2，可以是0、1、2，只有一个孩子是左/右孩子均可，上面是二叉树的所有可能组成部分。

1、完全二叉树&满二叉树

满二叉树有h层，且每层的结点都是满的。共  2^h-1个结点

完全二叉树有h层，前h-1层满，最后一层最少一个，结点n的范围是        2^(h-1)<=n<= 2^h-1

2、二叉树的性质 （几个公式）

首先，设孩子为0/1/2的结点总数分别为N0/N1/N2

可得  N0 = N2+1  该等式恒成立。  N1的数量是不确定的。

但是对于满二叉树。N1=0,  观察一下图就知道了。

对于完全二叉树，N1 = 0或1.

二叉树的深度H： H=logN（约等于），所以从上到下遍历一遍的时间复杂度为O（logN）

3、孩子与父亲的关系（互相查找）

假设将二叉树的结点，从上到下，从左到右，从0开始标记结点的个数，设孩子下标为child，父亲的下标为parent，则有以下关系

1、parent = （child-1）/ 2     左右孩子均满足

2、左孩子：  child = 2*parent +1

3、右孩子：  child = 2*parent +2

同时，如果结点总数为n，此时把n看作是下标，child必须<n，孩子结点才能存在，即 0~n-1

三、堆的概念

1、二叉树的顺序存储结构

 与链表类似，堆这种数据结构也是分为物理结构和逻辑结构。

逻辑结构上是一棵完全二叉树，物理结构上是顺序表。

上图中为普通二叉树的两种结构，如果不是完全二叉树，就会导致顺序表的空间浪费，例如：最下面一层如果只有最后一个结点存在，那么顺序表的一半左右大小的空间就会被浪费，而堆的产生，就是为了解决这种空间浪费的。完全二叉树的结构使其能更好的利用顺序的空间。

2、堆的分类

 分为  大根堆和小根堆两种，即每个parent结点的val值的大小，都要比其child结点的val大或小。

四、堆的接口函数

typedef int HPDatatype;

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

//堆的初始化
void HPInit(HP* php);
//堆的销毁
void HPDestroy(HP* php);
//入数据
void HPPush(HP* php, HPDatatype x);
//删除数据
void HPPop(HP* php);
//判断堆是否为空
bool HPEmpty(HP* php);
//返回堆中元素个数
int HPSize(HP* php);
//返回堆顶元素
HPDatatype HPTop(HP* php);
//交换2个数据
void Swap(HPDatatype* p1, HPDatatype* p2);
//向下调整
void AdjustDown(HPDatatype* a, int parent, int size);
//向上调整
void AdjustUp(HPDatatype* a, int child);

五、初始化

//堆的初始化
void HPInit(HP* php)
{
	assert(php);

	HPDatatype* tmp = (HPDatatype*)malloc(sizeof(HPDatatype) * 4);
	if (NULL == tmp)
	{
		perror("malloc fail");
		return ;
	}

	php->a = tmp;
	php->capacity = 4;
	php->size = 0;

}

堆的结构与顺序表类似，都是一个指针指向物理存储的数组，size表示现有数据的个数，capacity表示当前的容量。

malloc一段空间给指针a，然后调整size为0，capacity初始化为4个元素的大小。

六、插入数据

先判断物理空间上的存储是否足够，不够就增容。

在size位置插入数据后，要对数据进行向上调整操作 （向上调整的原因是为了维持堆的结构，因为插入的数据的值的大小是不确定的，如果不调整就会破坏堆的结构，因此从第二个数据开始，就要不断向上调整）。

传入的参数为a指向的数组，以及刚刚插入的，要调整的数据的下标

七、向上调整函数

传入child下标，通过parent = (child-1)/2找到其父亲结点的下标位置，因为这里以大根堆为例，因此，只要a[child]>a[parent]就交换，交换完后，孩子变为原来的父亲，父亲继续找他的父亲，这样向上迭代，直到child变为0，即堆顶，它就是堆中最大的元素了，没有调整空间了。或者是不满足孩子大于父亲的条件，直接跳出了。

 

交换函数

只是实现简单的两个元素的数据交换，注意函数的返回值类型，以及传入的是地址。

 八、删除数据

一开始的size是删除前堆中元素的总数，我这里先让size--，使其指向被删除的那个元素，然后交换堆顶元素和要删除的元素，最后对堆顶的元素进行向下调整操作。

实现时可以改变顺序，但是一定要保证前后逻辑的统一，包括下面的向下调整函数的实现。

九、向下调整函数

这里的size接收的是pop函数中的size-1，即现在的size为向下调整的数据范围，共size个。

因为交换数据后，最大的数据来到数组的最后位置，我们只是通过size--来避免访问他，并没有真正的将它删除，因此原来在数组最后，现在在堆顶的那个元素，在向下调整时不能包含被删除的那个元素。

函数过程分析：parent为向下调整的那个元素，先通过 child = parent*2+1找到它的左孩子，进入循环后先判断一步，找出左右孩子中较大的那个，其中，child+1<size是为了保证右孩子也在数组范围内，如果不在，就默认为左孩子大了。

找出较大的孩子后，将其val值与parent比较，如果大于parent就交换，然后父亲变为孩子，孩子继续向下迭代找他的孩子，直到child>=size，超出数组范围。

 

十、返回个数、堆顶、销毁函数

这几个函数很简单，与前面的几种数据结构相似，这里不多陈述。

十一、测试结果

 

 插入的结果为大堆。

 由于删除后不会访问最后一个元素，所以除了原来的最大值8外，其它7个数字仍然满足大堆结构

 

通过循环  取出堆顶元素+删除操作，可以获取所有堆顶元素。

 引入k变量可以取出k个堆顶元素，又因为堆顶元素都是堆中最大或最小的，因此可以解决后面的topk问题。

十二、函数实现具体代码

#include"Heap.h"

//堆的初始化
void HPInit(HP* php)
{
	assert(php);

	HPDatatype* tmp = (HPDatatype*)malloc(sizeof(HPDatatype) * 4);
	if (NULL == tmp)
	{
		perror("malloc fail");
		return ;
	}

	php->a = tmp;
	php->capacity = 4;
	php->size = 0;

}

//交换函数（交换父子数据）
void Swap(HPDatatype* p1, HPDatatype* p2)
{
	HPDatatype tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;

}


//向上调整，任意传入一个下标，对它及其祖先进行向上调整，前提是左右子树都是  大/小堆
void AdjustUp(HPDatatype* a, int child)
{
	//chile 和 parent 都是下标的数字
	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 HPPush(HP* php, HPDatatype x)
{
	assert(php);
	//先判断是否需要增容，如需要则增容
	if (php->size == php->capacity)
	{
		HPDatatype* tmp = (HPDatatype*)realloc(php->a, sizeof(HPDatatype) * 2 * (php->capacity));
		if (NULL == tmp)
		{
			perror("realloc fail");
			return;
		}
		php->a = tmp;
		php->capacity *= 2;
	}

	//入数据  先插入到尾部，即物理存储上数组的最后，然后向上调整
	php->a[php->size] = x;
	AdjustUp(php->a,php->size);
	php->size++;

}


//判断堆是否为空
bool HPEmpty(HP* php)
{
	return php->size == 0;
}

//向下调整,前提是左右子树都是  大/小堆
void AdjustDown(HPDatatype* a, int parent,int size)
{
	int child = parent * 2 + 1;
	while (child < size)//叶结点为止，叶节点没有孩子，即child下标超过数组范围
	{
		//先找出来2个子节点中较大的那一个,因为parent的值要和较大的比较
		//此时如果交换，值大的child变为parent，满足比他的兄弟大
		if ((child+1 < size) && a[child + 1]>a[child])//起始的child一定是左孩子,检查越界
		{
			child = child + 1;
		}
		//向下调整
		if (a[child] > a[parent])
		{
			Swap(&a[parent], &a[child]);
			parent = child;
			child = child * 2 + 1;//每次都从左边的节点开始
		}
		else
		{
			break;
		}

	}

}


//删除数据   删除堆顶的元素才有意义，根据大根堆和小根堆，可以得到top为max或min
void HPPop(HP* php)
{
	assert(php);
	assert(!HPEmpty(php));

	//删完之后还要保证为堆的结构
	//如果只是简单的向前覆盖，由于物理上是数组存储，就会导致堆的父子结构被打乱,  无法通过下标关系找父/子
	//无法进行后续删除，因此可以选择首尾元素交换，删除尾部后，堆顶元素向下调整
	php->size--;
	Swap(&php->a[0], &php->a[php->size]);
	AdjustDown(php->a, 0, php->size);


}


//返回堆中元素个数
int HPSize(HP* php)
{
	assert(php);
	return php->size;
}
//返回堆顶元素
HPDatatype HPTop(HP* php)
{
	assert(php);
	return php->a[0];
}

//堆的销毁
void HPDestroy(HP* php)
{
	assert(php);
	php->capacity = 0;
	php->size = 0;
	free(php->a);
}

//9 8 7 6 5 0 2 1 4 3

 今天讲的是堆的概念及其主要函数的实现，下一篇文章我将详细讲述堆的应用。如 堆排序、topk问题等，感谢各位看到最后。