几个概念

堆：堆本质就是一棵完全二叉树。
常用的两种堆：最大堆、最小堆。
1、最大堆（大顶堆）：堆的每个父节点都大于其孩子节点；

Key[i]>=Key[2i+1] && key[i]>=key[2i+2]

2、最小堆（小顶堆）：堆的每个父节点都小于其孩子节点；

Key[i]<=Key[2i+1] && key[i]<=key[2i+2]

堆的存储采用数组的方式，i结点的父结点下标就为(i–1) / 2。它的左右子结点下标分别为2 * i + 1和2 * i + 2。

堆排序：
堆排序的基本思想是：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。

这个过程想着很简单，但是实际写起来代码的话又很奇怪，关键理解两大过程：1、初始化的过程；2、动态调整的过程；

针对这两大过程进行理解，以排序4 6 8 5 9为例子。

初始化的过程

首先，4 6 8 5 9对应的完全二叉树如下。

原始二叉树.png

明显不是一个最大堆，初始化过程理解可以从下往上一层层引入进行理解。

引入最底层。

最底层.png

由于最底层只有叶子节点，所以肯定符合最大堆。

之后由下往上，由左往右一个个节点引入。

引入6.png

此时倒数第二层需要进行调整，即6需要往下移动。在这里只需要移动一次，具体动态调整的过程后面会讲到。

引入6.png

引入8之后，不影响，所以不进行调整。

最后引入最高层的4。此时发现还是需要调整，4与下面交换第一次之后发现会影响之前已经调整好的堆，因此还需要往下调整。

动态调整.png

可以看见初始化之后整个堆就是一个最大堆，且初始化过程是一个由下而上的过程。关键代码如下：

public static void sort(int arrs[]) {
    int n = arrs.length;
    //建立大顶堆
    for(int i = n / 2 - 1; i >= 0; i--) {
        adjustHeap(arrs, i, n);
    }
    ......
}

遗留了一个问题，adjustHeap这个就是一个动态调整的过程，即由下而上由左及右，每次引入，需要进行动态调整的过程，动态调整其实解决引入了一个新节点带来的不符合最大堆定义的问题。

动态调整的过程

动态调整的过程有一个关键的词汇“元素下沉”，这个词理解了之后就能理解动态调整的过程。首先，调整的原因是因为引入了一个新节点，调整的目标是要符合最大堆的定义。

以刚才的例子为例，在引入最顶层节点4的时候，第一次下沉之后，发现上面的堆满足了，下面的小堆不满足，因此需要进一步的下沉，下沉结束的条件有两个：
1、已经到最底层了，最底层明显没法再下沉，底层的标志就是子节点溢出，即2*i+1 >= n；
2、已经符合要求了，即下沉到的这个位置满足Key[i]>=Key[2i+1] && key[i]>=key[2i+2]，由于再往下没有动到，所以仍然满足（前提是往下已经完成初始化），往上是刚调整过的，因此也满足。此时，整棵树满足最大堆。

关键代码如下。

private static void adjustHeap(int arrs[], int i, int n) {
    int temp = arrs[i];
    for(int k = i * 2 + 1; k < n; k = k * 2 + 1) {
        if(k + 1 < n && arrs[k] < arrs[k + 1]) {
            k++;
        }
        if(arrs[k] > temp) {
            //swap(arrs, i, k);
            arrs[i] = arrs[k];
            i = k;
        } else {
            break;
        }
    }
    arrs[i] = temp;
}

这里有一个小优化，即每次下沉过程其实不急着换，因为还可能继续下沉，因此没有直接swap（注释掉的语句）。

堆排序代码实现

这样，初始化过程和调整过程都有了，初始化完之后，得到最大堆，此时头节点即为最大值，所以我们需要将头结点和最后的叶子结点交换，此时，最大值有了，这个交换过程其实和初始化过程中，引入一个新节点一样，本质上就是引入一个新的头结点，所以需要和初始化过程一样，对新节点以下进行调整，有个不同的地方在于，最后一个子节点已经确定下来了，因此，不参与调整。这个过程代码如下：

//交换堆顶元素 并重新调整
for (int j = n - 1; j > 0; j--){
    swap(arrs, 0, j);
    adjustHeap(arrs, 0, j);
}

整个堆排序过程的代码如下：

/*堆排序*/
public class HeapSort {
    public static final String TAG = "HeapSort";

    public static void sort(int arrs[]) {
        int n = arrs.length;
        //建立大顶堆
        for(int i = n / 2 - 1; i >= 0; i--) {
            adjustHeap(arrs, i, n);
        }
        //交换堆顶元素 并重新调整
        for (int j = n - 1; j > 0; j--){
            swap(arrs, 0, j);
            adjustHeap(arrs, 0, j);
        }
    }

    private static void adjustHeap(int arrs[], int i, int n) {
        int temp = arrs[i];
        for(int k = i * 2 + 1; k < n; k = k * 2 + 1) {
            if(k + 1 < n && arrs[k] < arrs[k + 1]) {
                k++;
            }
            if(arrs[k] > temp) {
                arrs[i] = arrs[k];
                i = k;
            } else {
                break;
            }
        }
        arrs[i] = temp;
    }

    private static void swap(int arrs[], int x, int y) {
        int temp = arrs[x];
        arrs[x] = arrs[y];
        arrs[y] = temp;
    }
}