一、什么是堆
在讲述堆之前，首先看一下二叉树。
二叉树：
每个节点最多有两个子节点，且这两个子节点有左右次序之分。
1、满二叉树
二叉树的所有非叶子节点都被填满。
因此：一颗深度为 K 的满二叉树，其节点总数为：2的k次方 - 1
= 1 + 2 + 4 + 8 + ... + 2 pow(k-1)
= 2(0) + 2(1) + 2(2) + 2(3) + ... + 2(k-1) = 2pow(k) - 1
图（深度为 3 的满二叉树）：
2、完全二叉树
有 n 个节点，深度为 k 的二叉树，
当且仅当，这 n 个节点的排列序号，与深度为 k 的满二叉树中
序号为 1 至 n 的节点一一对应时，称之为完全二叉树。
即：
- 除了最外层，其它层都是有序且填满的。
- 上一层没有排完，不能排下一层。
图（深度为 3 的完全二叉树）：
3、堆
仅从数据结构角度看：符合完全二叉树的数据结构称之为：堆。
且，所有父节点比其下子节点都大（或小），
但，堆不要求每层中左右子节点的大小顺序。
将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。
二、堆的操作方法
1、插入节点
每次插入都是将新数据放在数组最后。然后依次向上调整。
直至符合：父节点比子节点都大（或小）。
2、删除节点
按定义，堆中每次都只能删除最顶层的那个节点（数组中索引为0的元素）。
为了便于重建堆，实际的操作是将数组最末尾的元素与根节点位置调换。
然后再只需调整根节点使其符合堆特性即可。（其它节点是已调整好的）
以最小堆为例：
调整根节点时先在左右子结点中找最小的，如果根结点比这个最小的子结点还小说明不需要调整了，
反之将父结点和它交换后，还需要再考虑后面的结点。相当于从根结点将一个数据的“下沉”过程。
三、堆与数组的关系
基于：数组的索引是从 0 开始（Zero-Based）：
从上图中可以发现，以数组表示的堆，其数据结构中的每个节点的索引值存在这样的特点：
父节点：parent(i) = (i - 1) >> 1;
子节点（左）：leftChild(i) = i * 2 + 1;
子节点（右）：rightChild(i) = i * 2 + 2;
任何一个数组，附以上述规则，那么这个数组就可以被看作是一个堆。
也就是说，堆可以用数组表示。反之：任何一个数组，都是一个堆。
堆的逻辑结构：完全二叉树
堆的存储结构：数组（内存中一块地址连续的空间），或：一堆空间。
既于，数组具天然有序索引这一特性：数组的索引就是一个排好序的堆。
那么，只需要按照数组的索引将其值放置为符合堆的规则即可——堆排序。
四、堆排序的过程
堆排序共分两步：
第一步：将数组堆化
把数组的每个节点，调整为具有堆的该特性：所有的父节点都比子节点大（或小）。
方法：遍历数组的每个节点
1、遍历的方向：从最外层向内层遍历（自底向上）
2、从哪里开始：从后向前数，从第一个非叶子节点开始遍历。
没有必要从叶子节点开始。（
叶子节点可以看作是已符合堆特点的节点。
因为它没有子节点，所以作为父节点，它就是最大的。）
第一个非叶子节点的索引值可以根据最后一个元素的索引值求得：
lastNodeIndex = (lastLeafIndex - 1) >> 1 = (arr.length - 2) >> 1;
3、每步遍历的规则：
虽然堆的子节点是不要求有大小顺序的，但是因为我们要对堆进行排序，
故：对于每个节点和它的子节点都要相互比较大小，
对于大堆，最大的那个排在父节点的位置。
对于小堆，最小的那个排在父节点的位置。
4、每步遍历多少次：如果子节点与父节点交换了位置，则交换位置后的父节点仍需要向下验证。
第二步：将堆化数组排序
堆排序的过程就是，不断移出最顶层（数组的第一个）元素的过程。
1、把移出的顶层元素与数组最后一个元素交换位置。
2、同时遍历的长度减 1，
3、然后从新调整剩余的数据，使其符合堆的特性。（
此时只需要调整最顶层元素即可，其它层都是已经被初始化好的）
重复该过程，直至需要遍历的数组长度为 0 。
排好序的堆就是一颗完全二叉树了：
1、所有的父节点都比子节点小（或大）
2、同一节点的左子节点比右子节点小（或大）
排序动画：
Javascript代码实现：
function heapSort(arr){
// step 1. heapify array
var len = arr.length - 1;
var lastNodeIndex = (len - 1) >> 1;
for(var i = lastNodeIndex; i >= 0; i--){
maxHeapify(arr, i, len);
}
// step 2. reduce heap
for(var i = 0; i < len; i++){
swap(arr, 0, len - i);
maxHeapify(arr, 0, len - i - 1);
}
return arr;
}
function swap(arr, i, j){
var temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
function maxHeapify(arr, index, len){
var li = (index << 1) + 1, // left child index.
ri = li + 1, // right child index.
cMax = li; // default Child Max valule.
if(li > len) return; // left child is out of range.
if(ri <= len && arr[ri] > arr[li]) // choose the bigger one.
cMax = ri;
if(arr[cMax] > arr[index]){ // if
swap(arr, index, cMax); // swapped,
maxHeapify(arr, cMax, len); // next check should be executed.
}
}
/*
// alternative method for maxHeapify();
function maxHeapify2(array, index, len) {
var iLeft, iRight, iMax;
while (true) {
iLeft = (index << 1) + 1;
iRight = iLeft + 1;
iMax = iLeft;
if(iLeft > len) break;
if(iRight <= len && array[iRight] > array[iLeft])
iMax = iRight;
if(array[iMax] <= array[index]) break;
swap(array, iMax, index);
index = iMax;
}
}
*/
测试：
var arr = [1,23,14,8,10,9,235,21,45,56,4,32,79,15,56,985,343]; heapSort(arr); // [1, 4, 8, 9, 10, 14, 15, 21, 23, 32, 45, 56, 56, 79, 235, 343, 985]
Java 版本：
import java.util.Arrays;
public class HeapSort {
private int[] arr;
public HeapSort(int[] arr){
this.arr = arr;
}
/**
* 堆排序的主要入口方法，共两步。
*/
public void sort(){
/*
* 第一步：将数组堆化
* beginIndex = 第一个非叶子节点。
* 从第一个非叶子节点开始即可。无需从最后一个叶子节点开始。
* 叶子节点可以看作已符合堆要求的节点，根节点就是它自己且自己以下值为最大。
*/
int len = arr.length - 1;
int beginIndex = (len - 1) >> 1;
for(int i = beginIndex; i >= 0; i--){
maxHeapify(i, len);
}
/*
* 第二步：对堆化数据排序
* 每次都是移出最顶层的根节点A[0]，与最尾部节点位置调换，同时遍历长度 - 1。
* 然后从新整理被换到根节点的末尾元素，使其符合堆的特性。
* 直至未排序的堆长度为 0。
*/
for(int i = len; i > 0; i--){
swap(0, i);
maxHeapify(0, i - 1);
}
}
private void swap(int i,int j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
/**
* 调整索引为 index 处的数据，使其符合堆的特性。
*
* @param index 需要堆化处理的数据的索引
* @param len 未排序的堆（数组）的长度
*/
private void maxHeapify(int index,int len){
int li = (index << 1) + 1; // 左子节点索引
int ri = li + 1; // 右子节点索引
int cMax = li; // 子节点值最大索引，默认左子节点。
if(li > len) return; // 左子节点索引超出计算范围，直接返回。
if(ri <= len && arr[ri] > arr[li]) // 先判断左右子节点，哪个较大。
cMax = ri;
if(arr[cMax] > arr[index]){
swap(cMax, index); // 如果父节点被子节点调换，
maxHeapify(cMax, len); // 则需要继续判断换下后的父节点及其以下的子节点，是否符合堆的特性。
}
}
/**
* 测试用例
*
* 输出：
* [0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 9]
*/
public static void main(String[] args) {
int[] arr = new int[]{3,5,3,0,8,6,1,5,8,6,2,4,9,4,7,0,1,8,9,7,3,1,2,5,9,7,4,0,2,6};
new HeapSort(arr).sort();
System.out.println(Arrays.toString(arr));
}
}
五、堆排序分析
堆排序与归并排序一样，是一种时间复杂度为O(N * logN)的算法，
同时和插入排序一样，是一种就地排序算法(不需要额外的存储空间)。
-
转载请注明，
原文出处：http://lixh1986.iteye.com/blog/2354246
-
引用：
堆_(数据结构)
https://zh.wikipedia.org/wiki/堆_(数据结构)
常见排序算法 - 堆排序 (Heap Sort)
http://bubkoo.com/2014/01/14/sort-algorithm/heap-sort/
堆排序详解
http://blog.csdn.net/daiyudong2020/article/details/52529791
堆排序详解
http://www.cnblogs.com/hdk1993/p/4635923.html
堆排序 - 维基百科
https://zh.wikipedia.org/wiki/堆排序