1. 二叉堆定义
（1）堆是一个完全二叉树
（2）堆中每一个节点的值都必须大于等于（或小于等于）其子树中每个节点的值。
第一点，堆必须是一个完全二叉树。，除最后一层，其他层的节点个数都是满的，最后一层的节点都靠左排列。
第二点，堆中的每个节点的值必须大于等于（或者小于等于）其子树中每个节点的值。也可以理解为，堆中每个节点的值都大于等于（或者小于等于）其左右子节点的值。
这里我们借助于堆这种数据结构实现的排序算法，就叫作堆排序。这种排序方法的时间复杂度非常稳定，是O(nlogn)，并且它还是原地排序算法。
对于每个节点的值都大于等于子树中每个节点值的堆，叫作“大顶堆”
对于每个节点的值都小于等于子树中每个节点值的堆，叫作“小顶堆”
2. 堆的操作
堆的操作基本就是 3 种，掺入、删除和排序，下面就讲一下这几种操作的过程以及代码实现。
完全二叉树比较适合用数组来存储。用数组来存储完全二叉树是非常节省存储空间，不需要存储左右子节点的指针，单纯地通过数组的下标，就可以找到一个节点的左右子节点和父节点。
左子节点 = 父节点 * 2 + 1
右子节点 = 父节点 * 2 + 2
下面几个过程均以大顶堆为例，小顶堆同样道理，只是大小相反。
2.1 插入节点
插入一个节点，需要将节点放到数组的尾部，然后执行向上堆化过程，这里成为【上浮】，保证堆顶部的元素最大，对每个父节点来说，均大于等于子节点。
public class Heap {
/**
* 堆的数组
*/
private int[] arr;
/**
* 堆的最大数据个数
*/
private int max;
/**
* 堆中数据个数
*/
private int size;
public Heap(int capacity) {
arr = new int[capacity];
max = capacity;
size = 0;
}
// 插入节点
public void insert(int value) {
if (size == max) {
return;
}
arr[size] = value;
int childIndex = size;
int parentIndex = (childIndex - 1) / 2;
while (childIndex > 0 && value > arr[parentIndex]) {
arr[childIndex] = arr[parentIndex];
childIndex = parentIndex;
parentIndex = (parentIndex - 1) / 2;
}
arr[childIndex] = value;
size++;
}
2.2 删除节点
删除节点，对于堆来说，删除一般是从堆顶删除，对于大顶堆，就是删除最大的元素，那么删除之后就需要再从堆中找到最大的元素，放到顶部。假设最后一个元素最大，把它放在顶部，然后执行向下堆化过程，这里称为【下沉】，执行这个过程之后，就将顶部元素下沉到某一个位置，每次下沉的条件是子元素的值比父元素大，需要完成交换，所以执行之后，就可以保证父节点的值大于等于子节点的值。
public int removeMax() {
if (arr == null || size == 0) {
return -1;
}
size--;
int result = arr[0];
arr[0] = arr[size];
downAdjust(arr, size, 0);
return result;
}
/**
* 下沉
*
* @param arr 数组
* @param size 数组大小
* @param i 索引
*/
private static void downAdjust(int[] arr, int size, int i) {
int temp = arr[i];
int parentIndex = i;
int childIndex = 2 * parentIndex + 1;
while (childIndex < size) {
// 如果有右孩子，且右孩子大于左孩子的值，则定位到右孩子
if (childIndex + 1 < size && arr[childIndex] < arr[childIndex + 1]) {
childIndex++;
}
if (temp >= arr[childIndex]) {
break;
}
arr[parentIndex] = arr[childIndex];
parentIndex = childIndex;
childIndex = 2 * childIndex + 1;
}
arr[parentIndex] = temp;
}
2.3 排序
堆排序需要两个过程：建堆和
建堆：就是让所有非叶子节点依次下沉，从倒数第二排非叶子元素开始执行，一直循环到第一个元素，这样就保证所有父节点大于等于子节点，堆顶元素是最大的。
排序：建堆之后，由于堆顶元素最大，那么可以将最大元素和最后一个元素交换，这样最大值就确定了；然后将剩下的元素执行堆化，也就是将刚刚交换的元素下沉操作，这个过程之后，堆顶元素又是最大的，然后重复这个过程，就能将堆中元素完成从小到大的排序。
时间复杂度：
（1）每个堆化过程时间复杂度是 O(logn),因为树的高度是 logn,建堆总共次数是 n/2 * logn,所以建堆过程时间复杂度是 O(nlogn)
（2）排序过程：每个下沉过程时间复杂度是O(logn)，一共执行 n - 1 次，所以排序过程就是 O(nlogn)
最终堆排序过程就是 O(nlogn)
/**
* 构建堆
*
* @param arr 数组
* @param length 长度
*/
private static void buildHeap(int[] arr, int length) {
for (int i = (length - 2) / 2; i >= 0; i--) {
downAdjust(arr, length, i);
}
}
/**
* 堆排序
*
* @param arr 数组
* @param n n为数组长度
*/
public static void sort(int[] arr, int n) {
if (arr == null) {
return;
}
buildHeap(arr, n);
int k = n - 1;
while (k > 0) {
// 交换堆顶元素和最后一个元素
int temp = arr[0];
arr[0] = arr[k];
arr[k] = temp;
k--;
downAdjust(arr, k, 0);
}
}
