本文已参与「新人创作礼」活动，一起开启掘金创作之路。

1. 二叉树的顺序结构

普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储

:warning:需要注意的是这里的堆 和 操作系统虚拟进程地址空间中的堆 是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段

2. 堆的概念及结构

如果有一个关键码的集合，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：父亲节点小于（或大于）孩子节点则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆

==堆的性质==

• ==堆中某个节点的值总是不大于或不小于其父节点的值==

• ==堆总是一棵完全二叉树。==

  

3. 堆的实现（以小堆为例）

3.1 Heap.h

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

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

void HeapInit(HP* php); // 堆的构建
void HeapDestroy(HP* php); // 堆的销毁

void Swap(HPDataType* pa, HPDataType* pb);//交换
void HeapPrint(HP* php);//打印堆中数据

void AdjustUp(HPDataType* a, size_t child);//向上调整
void HeapPush(HP* php, HPDataType x); //堆的插入

void AdjustDown(HPDataType* a, size_t size, size_t root);//向下调整
void HeapPop(HP* php);// 堆的删除

bool HeapEmpty(HP* php); // 堆的判空
size_t HeapSize(HP* php); // 堆的数据个数
HPDataType HeapTop(HP* php);// 取堆顶的数据

3.2 堆的构建

跟顺序表一样，在这不赘述了。如果忘记了请看还不会写顺序表？我手把手教你

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

3.3 堆的销毁

跟顺序表一样，在这不赘述了。

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

3.4 辅助函数

之后有用，在这先卖个关子。:stuck_out_tongue_winking_eye:

void Swap(HPDataType* pa, HPDataType* pb)
{
	HPDataType tmp = *pa;
	*pa = *pb;
	*pb = tmp;
}

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

3.5 向上调整、堆的插入

首先，把数据插入到堆中，之后为了保持小堆，我们写了个向上调整的函数来调用。

//向上调整
void AdjustUp(HPDataType* a, size_t child)
{
	size_t 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* php, HPDataType x)
{
	assert(php);
    //扩容
	if (php->size == php->capacity)
	{
		size_t newCapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
		HPDataType* tmp = realloc(php->a, sizeof(HPDataType) * newCapacity);
		assert(tmp);
		php->a = tmp;
		php->capacity = newCapacity;
	}
	//插入
	php->a[php->size] = x;
	++php->size;
	//保持堆，移位
	AdjustUp(php->a, php->size-1);
}

3.6 向下调整、堆的删除

==删除堆是删除堆顶的数据== 一开始我想到的是：直接把数据往前移动，覆盖第一个，但我发现这样的话有两大坏处： :one:挪动数据是O(N) :two:堆结构破坏了，父子间关系全都乱了，不可行。

之后找到一种巧妙的方法：将堆顶的数据跟最后一个数据交换换，然后删除数组最后一个数据，再进行向下调整算法。 时间复杂度是O(logN)，效率更高。

具体思路：选出左右孩子中小的孩子，如果孩子小于父亲，则它们之间交换，交换之后，将子节点看作新的父亲节点，继续向下调整，直到父亲节点的孩子不存在或孩子不小于父亲。

举个栗子:chestnut:： 现在我们给出一个数组，逻辑上看做一颗完全二叉树。我们通过从根节点开始的向下调整算法可以把它调整 成一个小堆。向下调整算法有一个前提：左右子树必须是一个堆，才能调整。 int array[] = {27,15,19,18,28,34,65,49,25,37} ;

//向下调整
void AdjustDown(HPDataType* a, size_t size, size_t root)
{
	size_t parent = root;
	size_t child = root * 2 + 1;
	while (child < size)
	{
		//选左右孩子中小的孩子
		if (child + 1 < size && 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* php)
{
	assert(php);
	assert(php->size > 0);

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

	//向下调整
	AdjustDown(php->a, php->size, 0);
}

3.7 堆的判空

bool HeapEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}

3.8 堆的数据个数

size_t HeapSize(HP* php)
{
	assert(php);
	return php->size;
}

3.9 取堆顶的数据

HPDataType HeapTop(HP* php)
{
	assert(php);
	assert(php->size > 0);
	return php->a[0];
}