树、二叉树、堆及其应用（堆排序、top-k问题）

树的概念与结构

概念：

与树相关的概念:

树的表示：

二叉树

概念：

特殊的二叉树：

二叉树性质：

二叉树的存储结构：

堆

堆的概念:

堆的实现：

堆的创建：

堆的插入：

堆的删除：

堆的应用

堆排序：

TOP-K问题：

树的概念与结构

概念：

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

每一棵树都有一个特殊的结点，称为根结点，根节点没有前驱结点
除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i<= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继。
树是递归定义的。

需要注意的是：树形结构中，子树之间不能有交集。

如上图一中B节点和A节点有交集，图二中A节点和C节点有交集，图三中C节点和D节点有交集，因此三个结构都不是树形结构。

与树相关的概念:

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

树的表示：

树结构相对线性表比较复杂，要存储表示起来就比较麻烦，既然保存值域，也要保存结点和结点之间的关系，实际中树有很多种表示方式如：双亲表示法，孩子表示法、孩子双亲表示法以及孩子兄弟表示法等。其中最常用的是孩子兄弟表示法。结构代码如下：

typedef int DataType;
struct Node
{
	struct Node* child; //孩子结点
	struct Node* brother; //指向其下一个兄弟结点
	DataType data; //数据域
};

二叉树

概念：

顾名思义，就是每个节点最多只有两个分叉即每个父节点至多有两个子节点的树形结构。

二叉树不存在度大于2的结点
二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

注意：对于任意二叉树，都可以由以下情况复合而成：

特殊的二叉树：

满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K（根节点层数为1），且结点总数是 2^k-1，则它就是满二叉树。

完全二叉树：完全二叉树是由满二叉树而引出来的，满二叉树是一种特殊的完全二叉树。对于一个层数为k（根节点层数为1）的二叉树，前k-1层为满二叉树，第k层中所有节点从左至右是连续的，则此二叉树为完全二叉树。高度为h的完全二叉树节点个数范围为：[2^(h-1)+1 , 2^h-1]。

二叉树性质：

1. 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有2^(i-1) 个结点.
2. 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是 2^h-1.
3. 对任何一棵二叉树, 如果度为0的叶结点个数为 n0, 度为2的分支结点个数为 n2,则有 n0＝n2＋1
4. 若规定根节点的层数为1，具有n个结点的满二叉树的深度，h=log2(n+1) . (log2(n+1) 是以2
为底，(n+1)的对数)
5. 对于具有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否则无右孩子

二叉树的存储结构：

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

顺序存储

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

观察数据存储和节点间的关系，可以发现：

父节点下标=(相应子节点下标-1)/2（子节点不分左右）；

左孩子下标=相应父节点下标*2+1；

右孩子下标=相应父节点下标*2+2。

链式存储

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

typedef int BTDataType;
// 二叉链
struct BinaryTreeNode_2
{
	struct BinTreeNode* Left; // 指向当前节点左孩子
	struct BinTreeNode* Right; // 指向当前节点右孩子
	BTDataType data; // 当前节点值域
}
// 三叉链
struct BinaryTreeNode_3
{
	struct BinTreeNode* Parent; // 指向当前节点的父节点
	struct BinTreeNode* Left; // 指向当前节点左孩子
	struct BinTreeNode* Right; // 指向当前节点右孩子
	BTDataType data; // 当前节点值域
}；

堆

相对于普通二叉树，完全二叉树更适合使用顺序结构存储。而现实中通常用顺序结构储存堆(和操作系统中存储数据的堆区不是一回事，此处的堆是一种存储数据的结构，也是一种二叉树)。

堆的概念:

一个数集中的所有元素按照完全二叉树的顺序存储方式存储在一个一维数组中，并满足：在二叉树结构中任一父节点值都大于等于子节点（任一父节点值都小于等于子节点值），则称为大堆或大根堆（小堆或小根堆）。

堆的性质：

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

堆的实现：

堆的创建：

想要创建一个堆，有两种方法：

向上调整建堆 (前边的数据必须是堆)

向下调整建堆 (左右子树必须是堆)

给定一个数组arr，arr数组逻辑上是一个完全二叉树，但还不是一个堆，存储顺序完全是随机的，当我们想要把arr数组变为一个堆时，也是可以用两种方法：

1、向下调整（时间复杂度：O(N)、空间复杂度：O(1)（不计算堆所占的空间））：因为向下调整时，要保证左右子树是堆，因此我们可以从数组倒数第一个非叶子节点开始，逐个元素向下调整，一直调整到根节点。

代码如下：

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

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

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

//向下调整(小堆)
void AdjustDown(HPDataType* a, int n, int parent)
{
	assert(a);
	int child = parent * 2 + 1;
	while (child < n)
	{
		//找出小的
		if (child + 1 < n && a[child] > a[child + 1])
		{
			child += 1;
		}

		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

//初始化
void HeapInitArray(HP* php, HPDataType* a, int n)
{
	assert(php);
	assert(a);
	php->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
	if (php->a == NULL)
	{
		perror("malloc failed");
		exit(-1);
	}
	php->capacity = n;
	php->size = n;
	//移入数据
	memcpy(php->a, a, sizeof(HPDataType) * n);
	//调整建堆	
	//向下调整
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(php->a, n, i);
	}
}

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

int main()
{
	HPDataType a[] = { 2,4,3,5,8,5,1,6,9,10,23,45,17,19 };
	HP hp;
	HeapInitArray(&hp, a, sizeof(a) / sizeof(a[0]));
	HeapPrint(&hp);

	HeapDestroy(&hp);
	return 0;
}

运行结果：

可以发现转换为二叉树形式后是一个小堆结构。

2、向上调整（时间复杂度：O(NlogN)、空间复杂度：O(1)（不计算堆所占的空间））：因为向上调整时，要保证前边的数据是堆，因此我们可以从数组的第二个元素开始，逐个元素向上调整，一直调整到最后一个叶子结点。

代码如下：

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

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

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

//向上调整(小堆)
void AdjustUp(HPDataType* a, int child)
{
	assert(a);
	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 HeapInitArray(HP* php, HPDataType* a, int n)
{
	assert(php);
	assert(a);
	php->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
	if (php->a == NULL)
	{
		perror("malloc failed");
		exit(-1);
	}
	php->capacity = n;
	php->size = n;
	//移入数据
	memcpy(php->a, a, sizeof(HPDataType) * n);
	//调整建堆	
	//向上调整
	int i = 0;
	for (i = 1; i < n; i++)
	{
		AdjustUp(php->a, i);
	}
}

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

int main()
{
	HPDataType a[] = { 2,4,3,5,8,5,1,6,9,10,23,45,17,19 };
	HP hp;
	HeapInitArray(&hp, a, sizeof(a) / sizeof(a[0]));
	HeapPrint(&hp);

	HeapDestroy(&hp);
	return 0;
}

运行结果：

与向下调整的运行结果相同，因此该组数也是一个小堆结构。

堆的插入：

想要在一个堆中插入数据，只需将想要插入的数据插入到堆尾，然后再对其进行向上调整，直至满足堆的结构即可。

代码如下：

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

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

void AdjustUp(HPDataType* a, int child)
{
	assert(a);
	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 HeapInitArray(HP* php, HPDataType* a, int n)
{
	assert(php);
	assert(a);
	php->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
	if (php->a == NULL)
	{
		perror("malloc failed");
		exit(-1);
	}
	php->capacity = n;
	php->size = n;
	//移入数据
	memcpy(php->a, a, sizeof(HPDataType) * n);
	//调整建堆
	 
	//向上调整
	int i = 0;
	for (i = 1; i < n; i++)
	{
		AdjustUp(php->a, i);
	}
}


void HeapPush(HP* php, HPDataType x)
{
	assert(php);
	if (php->capacity == php->size)//扩容
	{
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tem = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newcapacity);//当php->a为空时，realloc将执行malloc的功能
		if (tem == NULL)
		{
			perror("malloc failed");
			exit(-1);
		}
		php->capacity = newcapacity;
		php->a = tem;
	}

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

int main()
{
	HPDataType a[] = { 2,4,3,5,8,5,1,6,9,10,23,45,17,19 };
	HP hp;
	HeapInitArray(&hp, a, sizeof(a) / sizeof(a[0]));
	HeapPrint(&hp);

	HeapPush(&hp, 0);
	HeapPrint(&hp);

	HeapDestroy(&hp);
	return 0;
}

运行结果：

可以发现插入0前是小堆，插入0后还是小堆，没有改变数据的存储结构。

堆的删除：

一般说删除堆，都是要求删除堆顶元素即根节点，要达到此目的，只需将堆顶元素与堆尾元素互换，然后删除堆尾，再对新的堆顶元素进行向下调整，直至满足堆结构即可。

代码如下：

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

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

void AdjustDown(HPDataType* a, int n, int parent)
{
	assert(a);
	int child = parent * 2 + 1;
	while (child < n)
	{
		//找出小的
		if (child + 1 < n && a[child] > a[child + 1])
		{
			child += 1;
		}

		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void HeapInitArray(HP* php, HPDataType* a, int n)
{
	assert(php);
	assert(a);
	php->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
	if (php->a == NULL)
	{
		perror("malloc failed");
		exit(-1);
	}
	php->capacity = n;
	php->size = n;
	//移入数据
	memcpy(php->a, a, sizeof(HPDataType) * n);
	//调整建堆
	int i = 0;
	for (i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(php->a, n, i);
	}
}

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

void HeapPop(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);
}

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

int main()
{
	HPDataType a[] = { 2,4,3,5,8,5,1,6,9,10,23,45,17,19 };
	HP hp;
	HeapInitArray(&hp, a, sizeof(a) / sizeof(a[0]));
	HeapPrint(&hp);

	HeapPop(&hp);
	HeapPrint(&hp);

	HeapDestroy(&hp);
	return 0;
}

运行结果：

可以发现删除堆顶后并没有改变其数据的存储结构。

堆的应用

堆排序：

堆排序即利用堆的思想来进行排序，思路如下：
1. 建堆
升序：建大堆
降序：建小堆
2. 利用堆删除思想来进行排序
因为堆顶元素一定是最大值（或最小值）每次把堆顶元素与最后一个元素交换，然后把数组尾指针向前移动1，再对新的堆顶元素进行向下调整，重复上述操作，直至数组尾指针指向第一个元素，此时的数组中的数据就是一个有序的序列。

代码如下：

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

//获取根数据
HPDataType HeapTop(HP* php)
{
	assert(php);
	assert(php->size > 0);
	return php->a[0];
}
//判空
bool HeapEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}

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

//向下调整(小堆)
void AdjustDown(HPDataType* a, int n, int parent)
{
	assert(a);
	int child = parent * 2 + 1;
	while (child < n)
	{
		//找出小的
		if (child + 1 < n && a[child] > a[child + 1])
		{
			child += 1;
		}

		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}


//升序
//void HeapSort(int* a, int n)
//{
//	HP hp;
//	HeapInit(&hp);
//	//建堆（小堆）
//	for (int i = 0; i < n; i++)
//	{
//		HeapPush(&hp, a[i]);
//	}
//	
//	int i = 0;
//	while (!HeapEmpty(&hp))
//	{
//		a[i++] = HeapTop(&hp);//每次取堆顶元素依次放入数组
//		HeapPop(&hp);
//	}
//
//	HeapDestroy(&hp);
//}
// 这种写法的缺点：
// 1、先要创建一个堆的结构
// 2、空间复杂度、时间复杂度的消耗

//降序
void HeapSort(int* a, int n)
{
	//原地向下调整建堆（小堆）
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}

    //排序
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		end--;
	}
}

int main()
{
	int a[] = { 2,4,3,5,8,5,1,6,9,10,23,45,17,19 };
	HeapSort(a, sizeof(a) / sizeof(int));
	int i = 0;
	for (i = 0; i < sizeof(a) / sizeof(int); i++)
	{
		printf("%d ", a[i]);
	}
	return 0;
}

运行结果：

TOP-K问题：

即求一组数据中前K个最大的元素或者最小的元素。

对于Top-K问题，能想到的最简单直接的方式就是排序，然后取前k个元素（或后k个元素），但是：如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。最佳的方式就是用堆的特点来解决，基本思路如下：
1. 用数据集合中前K个元素建堆
若求前k个最大的元素，则建小堆
若求前k个最小的元素，则建大堆
2. 用剩余的N-K个元素依次与堆顶元素比较，不满足则替换堆顶元素，将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。

注意：当找到前k个元素后，若不单独进行排序操作，最后输出的结果并不一定是有序的！！！

代码如下：

//交换函数
void Swap(int* p1, int* p2)
{
	int k = *p1;
	*p1 = *p2;
	*p2 = k;
}

//向下调整(小堆)
void AdjustDown(int* a, int n, int parent)
{
	assert(a);
	int child = parent * 2 + 1;
	while (child < n)
	{
		//找出小的
		if (child + 1 < n && a[child] > a[child + 1])
		{
			child += 1;
		}

		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

//降序
void HeapSort(int* a, int n)
{
	//原地向下调整建堆（小堆）
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}

    //排序
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		end--;
	}
}


//前k个最大的
void PrintTopK(int * a, int k, int n)
{
	//建堆  前k个元素建堆(小堆)
	for (int i = (k - 2) / 2; i >= 0; --i)
	{
		AdjustDown(a, k, i);
	}

	//将剩余n-k个元素依次与堆顶元素比较
	int i = k;
	while (i<n)
	{
		if (a[i]>a[0])
		{
			//替换
			a[0] = a[i];
			//向下调整
			AdjustDown(a, k, 0);
		}
		i++;
	}

	for (int i = 0; i < k; i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
}

int main()
{
	int a1[] = { 2,4,3,5,8,5,1,6,9,10,23,45,17,19 };
	int n = sizeof(a1) / sizeof(a1[0]);
	HeapSort(a1, n);
	int i = 0;
	for (i = 0; i < n; i++)
	{
		printf("%d ", a1[i]);
	}
	printf("\n");

	int a2[] = { 2,4,3,5,8,5,1,6,9,10,23,45,17,19 };
	PrintTopK(a2, 5, n);
	return 0;
}

运行结果：

可以发现，虽然找出来最大的前 k 个元素，但是它们并不是有序的，这是因为我们在程序中找最大的前k个元素时，利用了堆结构，因此，当程序找到最大的前k个元素后，这k个元素是按照堆结构存储的，因此打印出来后并不是有序的。

想要打印出来的结果也是有序的，可以在找到后，再对数组前k个元素进行一次排序即可。

代码如下：

//交换函数
void Swap(int* p1, int* p2)
{
	int k = *p1;
	*p1 = *p2;
	*p2 = k;
}

//向下调整(小堆)
void AdjustDown(int* a, int n, int parent)
{
	assert(a);
	int child = parent * 2 + 1;
	while (child < n)
	{
		//找出小的
		if (child + 1 < n && a[child] > a[child + 1])
		{
			child += 1;
		}

		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

//降序
void HeapSort(int* a, int n)
{
	//原地向下调整建堆（小堆）
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}

    //排序
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		end--;
	}
}


//前k个最大的
void PrintTopK(int * a, int k, int n)
{
	//建堆  前k个元素建堆(小堆)
	for (int i = (k - 2) / 2; i >= 0; --i)
	{
		AdjustDown(a, k, i);
	}

	//将剩余n-k个元素依次与堆顶元素比较
	int i = k;
	while (i<n)
	{
		if (a[i]>a[0])
		{
			//替换
			a[0] = a[i];
			//向下调整
			AdjustDown(a, k, 0);
		}
		i++;
	}

	for (int i = 0; i < k; i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
}

int main()
{
	int a1[] = { 2,4,3,5,8,5,1,6,9,10,23,45,17,19 };
	int n = sizeof(a1) / sizeof(a1[0]);
	HeapSort(a1, n);
	int i = 0;
	for (i = 0; i < n; i++)
	{
		printf("%d ", a1[i]);
	}
	printf("\n");

	int a2[] = { 2,4,3,5,8,5,1,6,9,10,23,45,17,19 };
	PrintTopK(a2, 5, n);
    //单独对前5个元素排序
    HeapSort(a2, 5);
	for (i = 0; i < 5; i++)
	{
		printf("%d ", a2[i]);
	}
	return 0;
}

运行结果：