堆排序（十大经典排序算法之我的最爱）

一. 二叉堆

堆排序 就是把 数组元素 堆起来 排个序，这个堆长得跟树差不多，所以可以参考二叉树的样子理解二叉堆。

把数组元素填充到二叉树的节点上，每层从左到右的填充，由此建立了一颗完全二叉树

注意，这里说的是用二叉树的样子帮助理解二叉堆，二叉树不是真正存在的，它只是用来可视化数组元素之间的关系，啥关系呢？
如果父节点索引是 n，则左儿子索引是 2n+1，右儿子索引是 2n+2
不信你随便找一组父子节点验证验证。

我们的目的是排序，所以这颗虚拟二叉树就是我们接下来要实现排序的辅助对象。

二. 节点调整分析

因为二叉树和数组是映射关系，因此排序的最终结果是 编号为0的节点 对应着 数组最小值；编号为8的节点 对应着 数组最大值。

而操作二叉树（堆）几乎都从根节点开始，

1. 找出整棵树中最大的值推到根节点上，然后把根节点和最后的节点互换，从而把最大值保存到数组末尾，
2. 再从剩余的节点里找出次大值，将其再次推到根节点，再把根节点和倒数第二个节点互换，从而把次大值保存到数组次末尾。
3. 循环以上操作，直到没有能和根节点互换的节点（只剩根节点了）

在实现第一步前，我们要做个铺垫，保证对于任一父节点，父节点值必须 ≥ 任一儿子的值，这样保证了自根节点出发，到任一节点的有序性，为后续调整节省了时间。

三. 节点调整实践

完全二叉树（堆）有个特点，最后一个非叶子节点的索引是 “array.length / 2 - 1”，也就是数组长度的一半再减一

这个节点就是我们最开始要照顾的对象 —— 从它开始 保证父节点值 ≥ 任一儿子的值

从 编号为3 的节点开始调整

至此，根节点是最大值，且 任一父节点值 ≥ 任一儿子值，然后交换 根节点值 和 最后的节点值

这个步骤完成后，就得到了 [0, 8] 中的最大值，并存放于数组末尾，下轮最大值将从 [0, 7] 里查找，即执行以下步骤：

以 node[0] 为入口，调整二叉堆，保证 父节点值 ≥ 任一儿子值，最终 根节点拿到剩余部分的最大值，node[0] ↔ node[7]
以 node[0] 为入口，调整二叉堆，……，node[0] ↔ node[6]
以 node[0] 为入口，调整二叉堆，……，node[0] ↔ node[5]
……
以 node[0] 为入口，调整二叉堆，……，node[0] ↔ node[1]

4. 代码

	/**
	* 构建大顶堆（每次挑出最大值放到堆顶）
	* @arr 目标数组
	* @root 起始节点
	* @length 范围限制
	*/
	private void build(int[] arr, int root, int length){
		//先备份起始节点值
		//后面的调整代码是直接覆盖前面的值，最后把temp放到合适的位置
		//实际上每次调整本质是交换位置，为了省时间，采用覆盖值的方式
		int temp = arr[root];
		
		//从每个节点（n）的左子节点（2n+1）开始调整
		for(int i = 2 * root + 1; i < length; i = 2 * i + 1){
			
			//选出arr[root]、arr[i]、arr[i+1]三者中最大的作为父节点
			//先选出左、右子节点间较大的那个
			//i+1判断有没有右子节点
			if(i + 1 < length && arr[i] < arr[i + 1]){
				//让i指向较大的右子节点
				i++;
			}
			
			//此时i指向了较大的节点，跟temp比较
			if(arr[i] > temp){
				//本质就是交换位置
				arr[root] = arr[i];
				//让root指向子节点，以便后面继续调整
				root = i;
			}else{
				//arr[root]已经是最大的节点了
				break;
			}
		}
		//把temp放回最终的root位置
		arr[root] = temp;
	}
	private void swap(int[] arr, int i, int j){
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}

    /**
	* 堆排序：按层序排列数组元素，形成虚拟的完全二叉树
	* 大顶堆：任一父节点值大于等于两个子节点值，适用于升序排列元素
	* 小顶堆：任一父节点值小于等于两个子节点值，适用于降序排列元素
	*/
	public void heapSort(int[] arr){
		//1.构建大顶堆
		//从最后一个非叶节点（arr.length/2 - 1）开始，自底向上构建
		for(int i = arr.length/2 - 1; i >= 0; i--){
			build(arr, i, arr.length);
		}
		
		//2.将每次构建好的大顶堆，交换堆顶元素和末尾元素，再继续调整
		for(int i = arr.length - 1; i > 0; i--){
			//因为前面刚好建立好了大顶堆，这里可以先swap
			swap(arr, 0, i);
			//继续调整剩下的元素，再建立大顶堆
			//每次从根节点开始调整，而i恰好就是调整范围
			build(arr, 0, i);
		}
	}

五. 总结

堆排序的时间消耗相比冒泡、选择、插入等更少，空间消耗相比快排、归并更少，所以它是时空复杂度折中的基于交换的原地排序。