堆排序（英语：Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
想要了解堆排序，那么必须要明白堆这种数据结构，先介绍一下堆结构，如果已经明白了可以直接跳过。
什么是堆
堆是一种非常重要的数据结构，其本身是由完全二叉树构成的，二叉树想必大家都明白是什么，如果不明白请百度…堆需要分两种，一种叫大根堆，一种叫小根堆，先介绍这几个名词：
名词介绍
满二叉树：除了叶子节点，每个根节点都有完整的两个孩子：
完全二叉树：除了叶子节点，其他根节点必须都是满的，叶子节点可以不满，但是必须都在左边。如图：
大根堆：大根堆是以完全二叉树为基础的，每个根节点一定比它的左右两个孩子的值要大，看图：
小根堆：跟大根堆相反，每个根节点一定比左右两个孩子的值要小，如图：
了解了这几个名词和定义之后，就可以看堆排序了！！
堆排序怎么实现
为什么堆排序这么重要呢？？因为其复杂度是O（logN）的，要知道O(logN)比O(n²)要好太多太多了，比如要排序10亿个数据，log10亿只有28.9，而十亿的平方是多少就不用说了吧，性能差距太多了！！！所以面试堆排序必问，一定要完全地弄熟练这个排序！
堆排序其实是一种抽象的数据结构，它存储在一维数组中，画成树的样子只是便于理解，可是树怎么能存在一位数组当中呢？
堆有一种存放的原则，根节点的左孩子一定是（n * 2）+ 1，右孩子一定是（n * 2）+ 2，一个孩子的父节点一定是（n - 1） / 2.有一个特殊的根节点是0这个根节点，0的根节点套用公式是（0 - 1）/ 2，-1÷2其实还是0，所以大家不必担心。
所以首先需要将数组中无序的元素变成堆的这种结构，举个栗子：
比如1,2，3,4，5,6这六个元素已经依次排列在数组中了，这个例子是最不好的情况，也就是已经排好序的数组，看看他的时间复杂度会不会很高。
很显然如果用堆的结构排它是这样的
这很明显是一个小根堆，但是堆排序需要用大根堆，我们怎么把这个小根堆变成大根堆呢？
首先定义一个index，这个index从第1个元素开始，因为是从第0个元素默认它已经是一个大根堆结构了，走到2这个数字，进行判断，如果这个元素大于它的根节点（怎么找到它的父节点呢？（index - 1）/2），那么就进行交换，也就是1和2交换，堆中现在是2,1，数组中是(2,1)，3,4，5,6
index++，往堆中新增一个3，然后判断它跟父节点的关系，很明显3>2，所以就交换位置，堆中元素如下：数组中元素为(3,1，2),4，5,6
index++，往堆中新增一个4
很明显4比它的父节点1要大，那么就跟1交换位置
再进行判断，4比父节点3还要大，继续换，堆中位置如下，数组中：(4,3，2,1)，5,6
同理5,6也是这样排，最后堆中位置如下：
数组中为：6,4，5,1，3,2，那么怎么进行排序呢？？
先把第0位置的元素和第5位置的元素进行交换，也就是(2,4，5,1，3),6，size = 6，size-1，也就是堆中有效位置变成了从第0位置到第4位置，6就被排除了，堆中现在是：
所以需要一步操作叫heapify，就是把不是堆的结构变成堆结构，把index变量指向2，先找他的两个孩子哪个最大，然后让index和两个孩子的最大值进行比较，如果相等，则不需要交换位置，如果index小于最大值，则和这个最大值进行交换，也就是先找2的两个孩子哪个最大，显然是5，然后2和5比较，显然5大，所以交换位置，由于交换位置后2没有子节点了，所以停止比较，堆中位置如下：
在数组中的位置：5,4，2,1，3，6，虽然6还在，可是在堆的范围内它已经被排除在外了，所以是一个越界的元素，取到它也没用，实际上堆中的元素是5,4，2,1，3，然后还是弹出第0个元素，和–size进行交换，也就是5和3交换，变成(3,4，2,1)，5,6，堆中元素只剩下了3,4，2,1，再执行heapify方法，把其变成大根堆结构，也就是3和两个孩子节点中较大的那个元素比较，如果根节点小于孩子节点较大的那个元素，则和较大的元素进行交换，也就是3和4进行交换，堆变成了4,3，2,1，再执行交换，4,1交换，数组中变成(1,3，2),4，5,6，堆中元素只有1,3,2，1小于3，所以变成3,1，2，再执行交换，2,1，数组中元素变成(2,1)，3,4，5,6，然后堆中元素只剩下2,1了，所以2>1，然后进行交换，变成1,2，3,4，5,6，排序到此也就结束了。
看一下代码实现：
package com.bean.com.bean.sortAlg;
import java.util.Arrays;
public class HeapSort {
public static void HeapSort(int[] arr) {
if(arr == null || arr.length < 2) {
return;
}
for(int i = 0; i < arr.length; i++) {
HeapInsert(arr, i);//把数组变成堆结构
}
int size = arr.length;
swap(arr, 0, --size);第0位置元素和第--size元素进行交换
while(size > 0) {//只要堆空间还有元素
heapify(arr, 0, size);//把堆空间heap化
swap(arr, 0, --size);//再交换第0个元素和堆空间的最后一个元素
}
}
//把index之前的元素全部变成大根堆
public static void HeapInsert(int[] arr, int index) {
while(arr[index] > arr[(index - 1) / 2]) {//和父节点比较
swap(arr, index, (index - 1) / 2);
index = (index - 1) / 2;
}
}
//从index到size变成大根堆
public static void heapify(int[] arr, int index, int size) {
int left = index*2 + 1;//左孩子
while(left < size) {
int largest = arr[left + 1] > arr[left] && left + 1 < size ? left + 1 : left;
largest = arr[largest] > arr[index] ? largest : index;
if(largest == index) break;
swap(arr, largest, index);
index = largest;
left = index * 2 + 1;
}
}
public static void swap(int[] arr, int left, int right) {
int temp = arr[left];
arr[left] = arr[right];
arr[right] = temp;
}
public static int[] generateRandomArray(int maxSize, int maxNum) {
if(maxSize == 0) {
return null;
}
int[] randomArray = new int[(int) (Math.random() * (maxSize+1) )];
for(int i = 0; i < randomArray.length; i++) {
randomArray[i] = (int)(Math.random() * (maxNum+1) - (int)(Math.random() * (maxNum)));
}
return randomArray;
}
public static int[] arrayCopy(int[] arr) {
if(arr == null) {
return null;
}
int[] copyArray = new int[arr.length];
for(int i = 0; i < arr.length; i++){
copyArray[i] = arr[i];
}
return copyArray;
}
public static void printArray(int[] arr) {
if(arr == null) {
return;
}
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
System.out.println();
}
public static void ArrSort(int[] arr) {
Arrays.sort(arr);
}
public static boolean isEqual(int[] arr1, int[] arr2) {
if(arr1 == null && arr2 != null || arr1 != null && arr2 == null) {
return false;
}else if(arr1 == null || arr2 == null) {
return true;
}else if(arr1.length != arr2.length) {
return false;
}
for(int i = 0; i < arr1.length; i++) {
if(arr1[i] != arr2[i])
return false;
}
return true;
}
public static void main(String[] args) {
int maxSize = 20;
int maxNum = 50;
int testTimes = 50000;
boolean flag = true;
for(int i = 0; i < testTimes; i++) {
int[] arr1 = generateRandomArray(maxSize, maxNum);
int[] arr2 = arrayCopy(arr1);
ArrSort(arr1);
HeapSort(arr2);
flag = isEqual(arr1, arr2);
if (!flag) {
break;
}
}
System.out.println(flag ? "Congraduation! Everything is ok!" : "Damn.. the wrong " +
"method has been found..");
int[] arr1 = generateRandomArray(maxSize, maxNum);
printArray(arr1);
HeapSort(arr1);
printArray(arr1);
}
}
