堆实现TopK问题以及二叉树的基础知识铺垫

本文链接：https://blog.youkuaiyun.com/m0_53421868/article/details/120634994

本文详细介绍了树的概念和结构，包括节点的度、叶节点、分支节点、双亲节点和子节点等。接着，重点讲解了二叉树的特性，特别是满二叉树和完全二叉树的性质。此外，还探讨了堆的定义、性质，以及堆排序的原理和算法实现。最后，提到了堆在排序和TOPK问题中的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在这里插入图片描述

前言

一个（最大）二叉堆是一个具有最大堆特性的完全二叉树。所以在学习堆之前，我们先来学习一下二叉堆吧

在这里插入图片描述

树概念及结构

1.1树的概念
树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因
为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
有一个特殊的结点，称为根结点，根节点没有前驱结点
除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i
<= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继
因此，树是递归定义的。
在这里插入图片描述

1、节点的度：一个节点含有的子树的个数称为该节点的度；如上图：A1的为6 .
2、叶节点或终端节点：度为0的节点称为叶节点；如上图：B、C、H、I…等节点为叶节点
度为0的节点称为叶节点，没有孩子的结点就叫做叶子结点或者终端结点，而度不为0或者有孩子结点的就叫做非叶子结点或者非终端结点
3、非终端节点或分支节点：度不为0的节点；如上图：D、E、F、G…等节点为分支节点
有孩子的结点
4、双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；如上图：A是B的父节点
5、孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；如上图：B是A的孩子节点
6、兄弟节点：具有相同父节点的节点互称为兄弟节点；如上图：B、C是兄弟节点
7、树的度：一棵树中，最大的节点的度称为树的度；如上图：树的度为6
最大的节点是指拥有更多的孩子
8、节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
9、树的高度或深度：树中节点的最大层次；如上图：树的高度为4
有些书籍会用0表示树的第一层，树的高度从0依次递增
10、堂兄弟节点：双亲在同一层的节点互为堂兄弟；如上图：H、I互为兄弟节点
11、节点的祖先：从根到该节点所经分支上的所有节点；如上图：A是所有节点的祖先
12、子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如上图：所有节点都是A的子孙
13、森林：由m（m>0）棵互不相交的树的集合称为森林；
多棵树没有结点重叠的树，称之为森林

树的表示

树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，实际中树有很多种表示方式，如：双亲表示法，孩子表示法、孩子兄弟表示法等等。我们这里就简单的了解其中最常用的孩子兄弟表示法。

在这里插入图片描述

左孩子右兄弟表示法

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

在这里插入图片描述

从树的结构可以看出无论树中一个结点有多少个孩子，都可以表示，只需要找到第一个根结点，剩下的结点，都可以用兄弟指针关联，找到他

2.二叉树概念及结构

2.1概念
一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树
的二叉树组成。
二叉树的特点：

每个结点最多有两棵子树，即二叉树不存在度大于2的结点。
二叉树的子树有左右之分，其子树的次序不能颠倒。

2.4特殊的二叉树：

1、满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是
说，如果一个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。
2 、完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K 的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。
要注意的是满二叉树是一种特殊的完全二叉树。

二叉树的性质

若规定根节点的层数为1，则一棵非空二叉树的第n层上最多有2^(n-1) 个结点.
若规定根节点的层数为1，则深度为h的二叉树的最大结点数是2^h- 1.
对任何一棵二叉树, 如果度为0其叶结点个数为 n0, 度为2的分支结点个数为 n2,则有n0＝n2＋1
若规定根节点的层数为1，具有n个结点的满二叉树的深度，h=Log2(n+1). (ps：Log2(n+1)是log以2为
底，n+1为对数)
对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对
于序号为i的结点有：

若i>0，i位置节点的双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点
若2i+1<n，左孩子序号：2i+1，2i+1>=n否则无左孩子
若2i+2<n，右孩子序号：2i+2，2i+2>=n否则无右孩子

计算一个二叉树的总结点个数公式：2^k - 1
已知一颗满二叉树有N个结点，计算出他的高度是多少，公式log(N+1)

完全二叉树与满二叉树的区别

补充：
1、完全二叉树的前k-1层都是满的，最后一层可以不满但是从左往右都是连续的
2、满二叉树的第一层是满的，第k层有2^(k-1)个结点才是满的

练习题

某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（B ）
A 不存在这样的二叉树
B 200
C 198
D 199
2.下列数据结构中，不适合采用顺序存储结构的是（ A）
A 非完全二叉树
B 堆
C 队列
D 栈
3.在具有 2n 个结点的完全二叉树中，叶子结点个数为（A ）
A n
B n+1
C n-1
D n/2

总结点个数为2n
假设度为0节点有a0个
假设度为1节点有a1个
假设度为2节点有a2个
…
2n = a0 + a1 + a2
求出度为2的结点个数可以用完全二叉树的性质，度为0的结点个数比度为2的结点个数多1，a0 - 1等价于度为2的结点个数，所以可以得到下面的公式
2n = a0 + a1 + a0 - 1
进一步简化
2n = 2a0 - 1 + a1

有了这个结论后，可以进一步得到下面的公式
2n = 2a0 - 1 + 1
n = a0

4.一棵完全二叉树的节点数位为531个，那么这棵树的高度为（）
A 11
B 10
C 8
D 12

思路：
由于这颗树是一个完全二叉树，想要求出这颗树的结点个数，那就把它当作一个满二叉树看待，2^h - 1就是求出一颗满叉树的结点个数，但是完全二叉树最后一层缺少的结点个数是不确定的，那就把它假设为x

假设这个完全二叉树的高度为h，那么公式就是这样的
2^h - 1 - x = 531
继续做的工作是求出x的范围【1，2^(h - 1) - 1】，这里x的范围并不能从0开始，如果从0开始那么最后一层就不存在了，并且他是一个满二叉树，就失去完全二叉树的意义了，那么最后一层结点个数的最小值也求出来了，为1

再来看最大值，满二叉树的最后一层结点个数-1得到的就是完全二叉树的最大结点个数，所以完全二叉树的结点个数最大是2^(h-1)-1

所以x的范围【1，2^(h - 1) - 1】也是可以得到验证的，最后只需要将选项套进去就可以得到最接近x范围的选项了，答案选B
2^h - 1 - x = 531
2^10 - 1 - x = 531
1024 - 1 - 531 = x
x = 492

5.一个具有767个节点的完全二叉树，其叶子节点个数为（）
A 383
B 384
C 385
D 386

已知结点个数，求出度为0的结点个数
假设度为0的结点用a0表示
假设度为1的结点用a1表示
假设度为2的结点用a2表示
767 = a0 + a1 + a2
根据前面的知识，度为0的结点个数比度为2的结点个数多1，所以计算度为2的结点个数就是a0 - 1，进一步得到下面的公式
767 = a0 + a1 + a0 - 1
度为1的结点个数a1的情况分为两种，要么是0，要么是1

所以可以进一步推断公式
767 = 2a0 + a1 - 1
左边的式子是一个奇数，2a0表示的肯定是一个偶数，那么a0必然是0，这样子2a0这个偶数减去1得到的就是奇数
768 = 2a0
a0 = 384

3.2 堆的概念及结构

堆的性质：

Min-heap: 父节点的值小于或等于子节点的值；
Max-heap: 父节点的值大于或等于子节点的值；
堆总是一棵完全二叉树。

堆的存储

在物理结构中是以数组的形式存储的，在逻辑结构上是一个完全二叉树，实际在学习和使用的时候都是从逻辑结构为出发点，在这里会有一个规律，可以通过他的父亲计算出孩子的下标位置,这是以下公式：
计算左孩子：parent * 2 + 1
计算右孩子：parent * 2 + 2
通过孩子去计算父亲的位置：parent = (child - 1) / 2
parent这个变量表示的是树的第几层
在这里插入图片描述

堆排序

堆向下调整算法

向下调整算法的前提是：左子树和右子树恰好是小堆
向下调整算法的思想是将父亲跟孩子比较，如果小的孩子比父亲小，则跟父亲交换，而且把原来孩子的位置当成父亲继续往下调整，直到走到叶子结点
如果小的孩子比父亲大，则不需要处理，调整完成，整个树已经是小堆

在这里插入图片描述

void AdjustDown(int *arr,int n, int parent) 
{
	//默认左孩子小
	int child = parent * 2 + 1;
	while (child < n) 
	{
	    //如果右孩子比左孩子小，那就走到右孩子
		if (arr[child + 1] < arr[child]) 
		{
			++child;
		}
		//比较父子之间的大小关系，小的往上换
		if ( arr[child] < arr[parent] )
		{
			Swap(&arr[child],&arr[parent]);
			//将原来孩子的位置给父亲，继续算出新的孩子位置
			parent = child;
			child = parent * 2 + 1;
		}
		//已经是小堆了，不需要处理
		else 
		{
			break;
		}
	}
}

面对左右子树不是小堆的情况下，向下调整算法的优化

实现思路：如果左右子树不是堆的情况，使用向下调整算法肯定没有规律了，但是可以换一个角度考虑，从最后一个父亲位置开始把它作为一个子树，对它进行向下调整后这个子树就是小堆了，紧接着找到第二个子树依次…向下调整，最后左子树与右子树之间整体一调整就是一个堆了，已经用序列号标记好，将这几个圈起来的看作是一个子树，对每一个子树向下调整，会得到一个小堆，整体一调整会成一个大堆

代码实现：

//n-1是最后一个下标的位置，
//已知孩子位置求父亲位置的公式是parent = (child - 1) / 2
for(int i = (n - 1 - 1) / 2; i >= 0 ; i--)
{
	AdjustDown(arr,n,i);
}

建堆时间复杂度分析

在这里插入图片描述

堆排序的思考，为什么排升序要建大堆

1、堆排序要建堆，建堆时间复杂度：O(N)
2、建好堆了选数，堆排序的时间复杂度：O(N log N)

假设排升序建小堆，选出最小的数放到第一个位置，紧接着向下调整选出次小的
在这里插入图片描述

结论：堆排序排升序建小堆是没有意义的
那建大堆呢？
在这里插入图片描述

从最后一个父亲位置开始把它作为一个子树，对它进行向下调整后这个子树就是大堆了，紧接着找到第二个子树依次…向下调整，最后左子树与右子树之间整体一调整就是一个大堆了

建好大堆后再堆排序
在这里插入图片描述

利用堆删除思想来进行排序

思想：
先选出最大的和最后一个元素交换，再向下调整，再不把最后一个数看成是堆里面的，紧接着选出次大的，和最后一个元素交换，再向下调整，不把最后一个元素看作是堆里面的，依次循环直到只剩最后一个元素了，就可以认为是有序的了

反之如果是排降序呢？那就是建小堆了，选出最小的数与最后一个元素交换，再向下调整，紧接着不把它看作是堆里面的，再选次小，交换，向下调整，不看做堆元素，反反复复直到只剩最后一个元素就可以是降序了

结论
升序：建大堆，从它的效率上来看已经很优了。
降序：建小堆

堆排序代码实现

//交换
void Swap(int *data1,int *data2) 
{
	int tmp = *data1;
	*data1 = *data2;
	*data2 = tmp;
}
//打印
void print(int *arr,int n) 
{
	for (int i = 0; i < n; i++) 
	{
		printf("%d ",arr[i]);
	}
}

void AdjustDown(int *arr, int n, int parent) 
{
	int child = parent * 2 + 1;
	while (child < n) 
	{
		//右孩子比左孩子大
		if (child + 1 < n && arr[child + 1] > arr[child]) 
		{
			child++;
		}
		//孩子大于父亲就交换，通过孩子的位置去计算父亲的位置，再求父亲位置
		else if (arr[child] > arr[parent])
		{	
			Swap(&arr[child],&arr[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		//已经是小堆了
		else 
		{
			break;
		}	
	}
}

void SortHeap(int *arr, int n) 
{
	//建堆
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(arr, n, i);
	}
	//堆排
	int end = n - 1;
	//end > 0，不需要end >= 0 ,只剩最后一个元素就可以看作是有序的了
	while (end > 0) 
	{
		Swap(&arr[end],&arr[0]);
		AdjustDown(arr,end,0);
		//堆删除思想
		end--;
	}
}

int main()
{
	int arr[10] = { 27,15,19,18,28,34,65,49,25,37 };
	int n = sizeof(arr) / sizeof(arr[0]);
	SortHeap(arr, n);
	print(arr,n);
	return 0;
}

堆实现

接口声明

#pragma once
#include<stdio.h>
#include<stdbool.h>
#include<assert.h>
#include<stdlib.h>
#include<memory.h>
typedef int HPDataType;

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

//堆的初始化
void HeapInit(Heap *php, HPDataType *a, int n);
//打印
void Heapprint(Heap *php);
//销毁
void HeapDestroy(Heap *php);
//向下调整
void AdjustDown(int *arr, int n, int parent);
//向上调整
void AdjustUp(int *a, int child);
//堆排序
void SortHeap(int *arr, int n);
//插入
void HeapPush(Heap *php,int data);
//删除数据
void HeapPop(Heap *php);
// 取堆顶的数据
HPDataType HeapTop(Heap* php);
// 堆的数据个数
int HeapSize(Heap* php);
// 堆的判空
int HeapEmpty(Heap* php);

接口实现

#include"Heap.h"
void Swap(int *data1, int *data2)
{
	int tmp = *data1;
	*data1 = *data2;
	*data2 = tmp;
}
//建堆
void AdjustDown(int *arr, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && arr[child + 1] > arr[child])
		{
			child++;
		}
		//交换孩子和父亲
		if (arr[child] > arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
//堆排序
void SortHeap(int *arr, int n)
{
	//建堆，从最后一个父节点开始向下调整
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(arr, n, i);
	}
	//堆排
	int end = n - 1;
	while (end > 0)
	{
		Swap(&arr[end], &arr[0]);
		AdjustDown(arr, end, 0);
		end--;
	}
}

//堆的初始化
void HeapInit(Heap *php, HPDataType *a, int n)
{
	assert(php);
	php->a = (HPDataType *)malloc(sizeof(HPDataType) * n);
	if (php->a == NULL) 
	{
		perror("HeapInit::malloc");
		exit(-1);
	}
	php->size = php->capacity = n;
	//初始化
	memcpy(php->a,a,sizeof(HPDataType) * n);
	//建堆
	int i = 0;
	for (i = (php->size - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(php->a,php->size,i);
	}
}
//打印
void Heapprint(Heap *php) 
{
	assert(php);
	int i = 0;
	int k = 1;
	int pos = 0;
	for (i = 0; i < php->size; i++) 
	{
		
		printf("%d ", php->a[i]);
		if (pos % k == 0) 
		{
			printf("\n");
			k *= 2;
			pos = 0;
		}
		pos++;
	}
	printf("\n");

}
//销毁
void HeapDestroy(Heap *php) 
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->capacity = php->size = 0;
}
//向上调整
void AdjustUp(int *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(Heap *php, int data)
{
	assert(php);
	//插入值需要考虑库容
	if (php->size == php->capacity) 
	{
		php->a = realloc(php->a, sizeof(int) * php->capacity * 2);
		if (php->a == NULL) 
		{
			perror("HeapInsrt::malloc");
			exit(-1);
		}
		//二倍增长
		php->capacity *= 2;
	}
	
	//尾插
	php->a[php->size] = data;
	php->size++;
	//为了不改变堆的结构，向上调整
	AdjustUp(php->a,php->size - 1);
}

//删除数据
void HeapPop(Heap *php)
{
	assert(php);
	assert(php->size > 0);
	//交换第一个和最后一个，删除元素，向下调整
	int end = php->size - 1;
	Swap(&php->a[0], &php->a[end]);
	--php->size;
	AdjustDown(php->a, php->size, 0);
}

// 取堆顶的数据
HPDataType HeapTop(Heap* php) 
{
	assert(php);
	assert(!HeapEmpty(php));
	return php->a[0];
}
// 堆的数据个数
int HeapSize(Heap* php) 
{
	assert(php);
	return php->size;
}
// 堆的判空
int HeapEmpty(Heap* php) 
{
	assert(php);
	return php->size == 0 ? true : false;
}

初始化

//堆的初始化
void HeapInit(Heap *php, HPDataType *a, int n)
{
	assert(php);
	php->a = (HPDataType *)malloc(sizeof(HPDataType) * n);
	if (php->a == NULL) 
	{
		perror("HeapInit::malloc");
		exit(-1);
	}
	php->size = php->capacity = n;
	//初始化
	memcpy(php->a,a,sizeof(HPDataType) * n);
	//建堆
	int i = 0;
	for (i = (php->size - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(php->a,php->size,i);
	}
}

初始化堆的过程其实就是一个建堆的过程，用数组中可利用的元素完成建堆，有了这个堆结构后才能做后面的事情

打印

//打印
void Heapprint(Heap *php) 
{
	assert(php);
	int i = 0;
	int k = 1;
	int pos = 0;
	for (i = 0; i < php->size; i++) 
	{
		
		printf("%d ", php->a[i]);
		if (pos % k == 0) 
		{
			printf("\n");
			k *= 2;
			pos = 0;
		}
		pos++;
	}
	printf("\n");

}

遍历一遍堆，为了更醒目地呈现堆结构，这里将代码控制了一下

销毁

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

释放动态申请的空间

向下调整建堆

//建堆
void AdjustDown(int *arr, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		//选出左右孩子的大的那一个
		if (child + 1 < n && arr[child + 1] > arr[child])
		{
			child++;
		}
		//交换孩子和父亲
		if (arr[child] > arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		//已经是堆了就不需要再调整
		else
		{
			break;
		}
	}
}

选出左右孩子大的那一个跟父亲交换，孩子的位置给父亲继续计算下一个孩子的位置，这里建的是大堆

向上调整

void AdjustUp(int *a,int child)
{
	int parent = (child - 1) / 2;
	while (parent >= 0) 
	{
		if (a[child] > a[parent]) 
		{
			Swap(&a[child],&a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else 
		{
			break;
		}
	}
}

如果插入一个值后，需要调整推荐的是向上调整方式，如果是重新建堆的话效率太低了，而向上调整算法只需要调整一条路径的值，即使可以插入的值会改变原先的堆结构，但是这个算法的好处是可以不需要重新建堆

堆排序

//堆排序
void SortHeap(int *arr, int n)
{
	//建堆，从最后一个父节点开始向下调整
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(arr, n, i);
	}
	//堆排
	int end = n - 1;
	while (end > 0)
	{
		Swap(&arr[end], &arr[0]);
		AdjustDown(arr, end, 0);
		end--;
	}
}

前面已经有详细的介绍了，这里就不再继续

插入值

//插入
void HeapPush(Heap *php, int data)
{
	//插入值需要考虑库容
	if (php->size == php->capacity) 
	{
		php->a = realloc(php->a, sizeof(int) * php->capacity * 2);
		if (php->a == NULL) 
		{
			perror("HeapInsrt::malloc");
			exit(-1);
		}
		//二倍增长
		php->capacity *= 2;
	}
	
	//尾插
	php->a[php->size] = data;
	php->size++;
	//为了不改变堆的结构，向上调整
	AdjustUp(php->a,php->size - 1);
}

插入值后为了保证堆结构不被破坏，又希望希望不用建堆算法想效率高点，最好的方式是向上调整

删除

//删除数据
void HeapPop(Heap *php)
{
	assert(php);
	assert(php->size > 0);
	/
	int end = php->size - 1;
	Swap(&php->a[0], &php->a[end]);
	--php->size;
	AdjustDown(php->a, php->size, 0);
}

交换第一个和最后一个，删除元素，向下调整

取数据

// 取堆顶的数据
HPDataType HeapTop(Heap* php) 
{
	assert(php);
	assert(!HeapEmpty(php));
	return php->a[0];
}

获取元素个数

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

判断空

// 堆的判空
int HeapEmpty(Heap* php) 
{
	assert(php);
	return php->size == 0 ? true : false;
}

TOPK问题

剑指 Offer 40. 最小的k个数
链接: link.
题目描述：

输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。

实现思路：选出k个数建成堆，再往后比较数组中的元素，如果数组中的某个元素小于队顶元素就进堆，这样一来堆结构可能会被破坏，需要再次向下调整得到新的堆结构，直到数组遍历完最小的k个数也都被筛选出来了


typedef int HPDataType;

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

//堆的初始化
void HeapInit(Heap *php, HPDataType *a, int n);
//打印
void Heapprint(Heap *php);
//销毁
void HeapDestroy(Heap *php);
//向下调整
void AdjustDown(int *arr, int n, int parent);
//向上调整
void AdjustUp(int *a, int child);
//堆排序
void SortHeap(int *arr, int n);
//插入
void HeapPush(Heap *php,int data);
//删除数据
void HeapPop(Heap *php);
// 取堆顶的数据
HPDataType HeapTop(Heap* php);
// 堆的数据个数
int HeapSize(Heap* php);
// 堆的判空
int HeapEmpty(Heap* php);
void Swap(int *data1, int *data2)
{
	int tmp = *data1;
	*data1 = *data2;
	*data2 = tmp;
}
//建堆
void AdjustDown(int *arr, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && arr[child + 1] > arr[child])
		{
			child++;
		}
		//交换孩子和父亲
		if (arr[child] > arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
//堆排序
void SortHeap(int *arr, int n)
{
	//建堆，从最后一个父节点开始向下调整
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(arr, n, i);
	}
	//堆排
	int end = n - 1;
	while (end > 0)
	{
		Swap(&arr[end], &arr[0]);
		AdjustDown(arr, end, 0);
		end--;
	}
}

//堆的初始化
void HeapInit(Heap *php, HPDataType *a, int n)
{
	assert(php);
	php->a = (HPDataType *)malloc(sizeof(HPDataType) * n);
	if (php->a == NULL) 
	{
		perror("HeapInit::malloc");
		exit(-1);
	}
	php->size = php->capacity = n;
	//初始化
	memcpy(php->a,a,sizeof(HPDataType) * n);
	//建堆
	int i = 0;
	for (i = (php->size - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(php->a,php->size,i);
	}
}
//打印
void Heapprint(Heap *php) 
{
	assert(php);
	int i = 0;
	int k = 1;
	int pos = 0;
	for (i = 0; i < php->size; i++) 
	{
		
		printf("%d ", php->a[i]);
		if (pos % k == 0) 
		{
			printf("\n");
			k *= 2;
			pos = 0;
		}
		pos++;
	}
	printf("\n");

}
//销毁
void HeapDestroy(Heap *php) 
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->capacity = php->size = 0;
}
//向上调整
void AdjustUp(int *a,int child)
{
	int parent = (child - 1) / 2;
	while (parent >= 0) 
	{
		if (a[child] > a[parent]) 
		{
			Swap(&a[child],&a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else 
		{
			break;
		}
	}
}

//插入
void HeapPush(Heap *php, int data)
{
	assert(php);
	//插入值需要考虑库容
	if (php->size == php->capacity) 
	{
		php->a = realloc(php->a, sizeof(int) * php->capacity * 2);
		if (php->a == NULL) 
		{
			perror("HeapInsrt::malloc");
			exit(-1);
		}
		//二倍增长
		php->capacity *= 2;
	}
	
	//尾插
	php->a[php->size] = data;
	php->size++;
	//为了不改变堆的结构，向上调整
	AdjustUp(php->a,php->size - 1);
}

//删除数据
void HeapPop(Heap *php)
{
	assert(php);
	assert(php->size > 0);
	//交换第一个和最后一个，删除元素，向下调整
	int end = php->size - 1;
	Swap(&php->a[0], &php->a[end]);
	--php->size;
	AdjustDown(php->a, php->size, 0);
}

// 取堆顶的数据
HPDataType HeapTop(Heap* php) 
{
	assert(php);
	assert(!HeapEmpty(php));
	return php->a[0];
}
// 堆的数据个数
int HeapSize(Heap* php) 
{
	assert(php);
	return php->size;
}
// 堆的判空
int HeapEmpty(Heap* php) 
{
	assert(php);
	return php->size == 0 ? true : false;
}
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* getLeastNumbers(int* arr, int arrSize, int k, int* returnSize){
    if(k == 0)
    {
        *returnSize = 0;
        return NULL;
    }
   //选出k个数建堆，再往后比较数组中的元素，如果小于队顶元素就进堆，再向下调整
    Heap h;
    int* retArr = (int *)malloc(sizeof(int) * k);
    for(int i = 0; i < k; i++)
    {
        retArr[i] = arr[i];
    }

    for(int i = (k - 1 - 1) / 2; i >= 0; i--)
    {
        AdjustDown(retArr,k,i);
    }

    for(int i = k; i < arrSize; i++)
    {
        if(retArr[0] > arr[i])
        {
            retArr[0] = arr[i];
            AdjustDown(retArr,k,0);
        }
    }
    *returnSize = k;
    return retArr;
}