深入浅出C语言——C语言实现堆

一、树

1. 树的概念

  树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。

---

树的特点

  树有一个特殊的结点，称为根结点，根节点没有前驱结点。除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继。 树形结构中，子树之间不能有交集，否则就不是树形结构。另外，要注意树是递归定义的。

---

树相关的名词

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

---

2. 树的存储

  树结构存储既保存值域，也要保存结点和结点之间的关系。实际中树有很多种表示方式如：双亲表示法、孩子表示法、孩子双亲表示法、孩子兄弟表示法…等。其中最常用的孩子兄弟表示法。

typedef int DataType;
struct Node
{
	DataType _data; 			// 结点中的数据域
	struct Node* _firstChild1; 	// 第一个孩子结点
	struct Node* _pNextBrother; // 指向其下一个兄弟结点
};

  孩子兄弟表示法，即左孩子右兄弟表示法。无论树中一个节点有多少个孩子，都可以表示，因为这个表示法只指向第一个孩子，剩下的孩子，让孩子之间用兄弟指针串起来。

---

二、二叉树

1.概念

  一棵二叉树是结点的一个有限集合，该集合由一个根节点加上两棵分别称为左子树和右子树的二叉树组成或者为空。因为二叉树的这种结构，所以二叉树不存在度大于2的结点。另外，二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树。

---

2. 特殊的二叉树

满二叉树

  如果一个二叉树的每一个层的结点数都达到最大值，这个二叉树就是满二叉树。假设此二叉树的层数为K，那么它的结点总数是2^k-1。

---

完全二叉树

  完全二叉树的前K-1层都是满的，最后一层可以不满，但是从中到右都是连续的，满二叉树是一种特殊的完全二叉树。

---

3. 二叉树的性质

• 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有2^(i-1)个结点。
• 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是(2^h)-1。
• 对任何一棵二叉树, 如果度为0其叶结点个数为n0 , 度为2的分支结点个数为n2 ,则有n0＝n2 ＋1。简言之，度为0比度为2的永远多一个。
• 若规定根节点的层数为1，具有n个结点的满二叉树的深度，h= log2(n+1)。
• 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对于序号为i的结点有以下性质：(1)若i>0，i位置节点的双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点。(2)若2i+1<n，左孩子序号：2i+1，2i+1>=n否则无左孩子。(3)若2i+2<n，右孩子序号：2i+2，2i+2>=n否则无右孩子。

---

4. 二叉树的存储结构

  二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构。

---

顺序结构存储

  顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费，而现实中使用中只有堆才会使用数组来存储。二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。

---

链式结构存储

  二叉树的链式存储结构是用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址。

---

5. 二叉树的顺序结构

  普通二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆使用顺序结构的数组来存储。这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。

---

三、堆

1. 堆的概念

  堆是一颗完全二叉树，其满足堆中某个节点的值总是不大于或不小于其父节点的值。堆的父子间关系表示： leftchild=parent*2+1，rightchild=parent*2+2，parent=（child-1）/2

---

2. 堆的实现

/*****************************Heap.h*******************************/
#program once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

typedef int HPDataType;

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

// 堆的初始化
void HeapInit(HP* php);
// 堆的插入
void HeapPush(HP* php, HPDataType x);
// 堆的删除
void HeapPop(HP* php);
// 交换两个数
void Swap(HPDataType* p1, HPDataType* p2);
// 向上调整
void AdjustUp(HPDataType* a, int child);
// 向下调整
void AdjustDwon(HPDataType* a, int size, int parent);
// 堆的打印
void HeapPrint(HP* php);
// 获取堆顶的元素
HPDataType HeapTop(HP* php);
// 判断堆是否为空
bool HeapEmpty(HP* php);
// 堆的数据个数
int HeapSize(HP* php);
// 堆的销毁
void HeapDestroy(HP* php);

/*****************************Heap.c*******************************/
#include "Heap.h"

// 堆的初始化
void HeapInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->size = php->capacity = 0;
}

// 堆的插入
// 先插入一个数到数组的尾上，再进行向上调整算法，直到满足堆。
void HeapPush(HP* php, HPDataType x)
{
	assert(php);
	if (php->size == php->capacity)//扩容
	{
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		//realloc扩容
		HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newcapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		php->a = tmp;
		php->capacity = newcapacity;
	}
	//扩容后，插入数据
	php->a[php->size] = x;
	php->size++;
	//向上调整
	AdjustUp(php->a, php->size - 1);
}

// 堆的删除  删除堆的元素
// 如果挪动数据，覆盖删除，树中的父子关系全乱
// 删除堆是删除堆顶的数据，将堆顶的数据根最后一个数据一换，然后删除数组最后一个数据，再进行向下调整算法。
void HeapPop(HP* php)
{
	assert(php);
	assert(php->size > 0);
	// 把头和尾的数据交换，在把最后一个数据删除掉
	Swap(&(php->a[0]), &(php->a[php->size - 1]));
	php->size--;
	//向下调整算法（这里左子树和右子树仍然是堆）
	AdjustDwon(php->a, php->size, 0);//从根节点开始调整
}

// 交换两数
void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

// 向上调整算法
void AdjustUp(HPDataType* a, int child)
{
	assert(a);
	int parent = (child - 1) / 2;
	//最好用孩子来判断结束条件，不要用parent，因为parent不会小于0
	while (child > 0)//最坏调整到child=0的时候，也就是一路调整到根
	{
		//if (a[child] < a[parent])
		if (a[child] > a[parent])
		{
			//交换
			Swap(&a[child], &a[parent]);
			//迭代
			child = parent;
			parent = (child - 1) / 2;
		}
		else
			break;
	}
}

// 向下调整算法
/*1、选出左右孩子中小的哪一个
* 2、小的孩子跟父亲比较，如果比父亲要小，则交换，继续往下调整。如果大，则调整结束
* 3、最多调整到叶子就结束
*/
void AdjustDwon(HPDataType* a, int size, int parent)//以后可能会从中间开始调，所以parent不一定是0
{
	assert(a);
	// 默认左孩子小
	int child = parent * 2 + 1;
	// 到叶子就是孩子不存在，孩子不存在就是child>=parent
	while (child < size)
	{
		// 选出左右孩子中小/大的那个
		// 避免越界访问
		if (child + 1 < size && a[child + 1] > a[child])
		{
			child++;
		}
		// 孩子跟父亲比较
		if (a[child] > a[parent])
		{
			//交换
			Swap(&a[child], &a[parent]);
			//迭代
			parent = child;
			child = parent * 2 + 1;
		}
		else
			break;
	}
}

// 打印堆
void HeapPrint(HP* php)
{
	assert(php);
	for (int i = 0; i < php->size; ++i)
	{
		printf("%d ", php->a[i]);
	}
	printf("\n");
}

// 获取堆顶的元素
HPDataType HeapTop(HP* php)
{
	assert(php);
	assert(php->size > 0);
	return php->a[0];
}

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

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

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

---

建堆

  上述代码是堆的数据结构模拟实现，但是在实际工程中并不常用，因为你得先写一个Hp数据结构，反而复杂并且还有有O(N)空间复杂度。实际上，一般不用写堆的数据结构，只需要在原数组上建堆，不需要开辟额外的空间。核心是向上调整算法和向下调整算法。

---

向上调整建堆

   向上调整算法是遍历一个数组，对数组中的每个元素都进行向上调整，遍历完后，这个数组就变成堆啦

void AdjustUp(HPDataType* a, int child)// 向上调整算法
{
	/****/ //代码实现见堆实现中的代码
}
// 建堆方式1：向上调整建堆
// O(N*logN)
for (int i = 1; i < n; ++i)
{
	AdjustUp(a, i);
}

---

向下调整建堆

   向下调整算法建堆有一个前提，左右子树必须是一个堆，才能调整。算法思想是从倒数第一个非叶子节点开始，一直到根节点递减，都进行向下调整。

void AdjustDwon(HPDataType* a, int size, int parent)
{
	/****/ //代码实现见堆实现中的代码
}
// 建堆方式2：向下调整建堆
// O(N)
// 从倒数的第一个非叶子节点，因为叶子节点不需要调
// n-1是下标，再-1除2就找到了倒数的第一个非叶子节点
for (int i = (n - 1 - 1) / 2; i >= 0; --i)
{
	AdjustDwon(a, n, i);
}

---

3. 堆的应用

堆排序

   堆排序即利用堆的思想来进行排序，总共分为两个步骤：1.建堆，升序建大堆，降序建小堆。2.利用堆删除思想来进行排序 。堆排序的时间复杂度是O(N*logN)

---

为什么排升序要建大堆

  排升序时，如果建小堆， 最小的数已经在堆顶的位置上，但是除了堆顶以外，剩下的数都不是有序的，如果需要找出剩下的数中最小的数，需要重新建堆这样排序的时间复杂度太大，还不如直接遍历排序。所以需要建立大堆，堆顶是最大的数，然后同最后一个数交换，再把交换后的堆顶数向下调整，然后重复交换再向下调整新堆顶数，直到实现排序。

---

代码实现

#include<stdio.h>
void Swap(int* p1, int* p2)
{
	/****/
}

void AdjustDwon(int* a, int size, int parent)
{
	/****/
}
// 堆排序：
void HeapSort(int* a, int n)
{
	
	// 向下调整建大堆 O(N)
	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDwon(a, n, i);
	}

	// 依次调整大的数据放到堆尾
	// O(N*logN)  总时间复杂度O(N*logN)+O(N)——>O(N*logN)
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		//选出次大的
		AdjustDwon(a, end, 0);
		--end;
	}
}

int main()
{
	int a[] = { 27, 15, 19, 18, 28, 34, 65, 49, 25, 37 };
	HeapSort(a, sizeof(a) / sizeof(int));//排升序
	for (int i = 0; i < sizeof(a) / sizeof(int); i++)
	{
		printf("%d ", a[i]);
	}
	return 0;
}

---

TOP-K问题

   TOP-K问题即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了，因为可能数据都不能一下子全部加载到内存中，最佳的方式就是用堆来解决。

---

TOP-K问题基本思路

1. 用数据集合中前K个元素来建堆，求前k个最大的元素则建小堆，求前k个最小的元素则建大堆。
2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素，再调整堆，将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。

---

案例——求数组中最大的五个元素

---

复杂度

  时间复杂度：O(N*logN) 空间复杂度：O(N)，时间复杂度没有提高，但是空间复杂度利用率特别高。