堆排序

1.首先我们应该明白什么是堆？

堆通常可以被看做一颗特殊的二叉树。堆总是满足下列性质：

• 堆中某个节点的值总是不大于或不小于其父节点的值；
• 堆总是一棵完全二叉树。

将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

从图中可以看出，父节点下标和左右子节点下标具有一定的关系，所以我们很容易去模拟父节点和子节点的关系：

parent = (children-1) / 2;
childrenLeft = 2*parent +1;
childrenRight = 2*parent +2; 　

2.知道了堆是什么之后，就可以使用堆的特点进行排序了~

堆的数据结构决定了大跟堆的堆顶元素是最大值，小跟堆的堆顶元素是最小值。我们可以通过依次取到堆顶元素即无序区间的最大的数，来确定有序区间。下面我们以排升序为例：

！！！注意：排升序要建大堆；排降序要建小堆。




综上，我们在排序的过程中涉及三个步骤
（1）交换堆顶元素和最后节点元素；
（2）缩小无序区间，砍掉最后一个节点；
（3）重新建堆。
但是，我们在排序的过程中首先要有一个堆。

3.如何建堆？

上述的过程中，我们可以发现两种需要建堆的初始情况：
（1）完全无序的二叉树，要调整成堆的结构。我们第一步中使用到的堆。
（2）只有根节点不是堆的结构，它的所有子树都还是堆。我们在交换完堆顶元素和最后节点元素之后的情况。
如果是第二种情况，我们需要对某个节点开始进行堆化，我们称之为heapify。对一个节点做heapify，必须保证所有子树都已经是堆了。
下面我们以大堆为例做heapify()代码的实现：

// heapify() 对保证所有子树都是堆的节点(i)实现堆化
private static void heapify(int[] tree, int n, int i){
    int c1 = 2*i+1;   // 左子树
    int c2 = 2*i+2;   // 右子树
    // 1. 找出i, c1, c2中的最大值(确保c1, c2存在)
    int max = i;
    if(c1 < n && tree[c1] > tree[max]) {
        max = c1;
    }
    if(c2 < n && tree[c2] > tree[max]) {
        max = c2;
    }
    // 2. 如果 max 不是 i ，则交换 max 与 i 的位置
    if(max != i) {
        swap(tree, max, i);
        // 3. 对max节点递归做heapify.
        heapify(tree, n, max);
    }
}

实现heapify()函数之后，我们发现它只能对所有子树都是堆的树做。如果是第一种情况的完全无序树，建堆需要从最后一个非叶子节点开始循环调用heapify() 。下面是buildHeap()代码实现：

// 从最后一个非叶子节点开始，循环使用heapify()函数建堆
private static void buildHeap(int[] tree, int n) {
    // 1. 找到最后一个非叶子节点
    int lastNode = n - 1;
    int pLastNode = (lastNode-1) / 2;
    // 2. 从最后一个非叶子节点开始，循环使用heapify
    for(int i = pLastNode; i >= 0; i--) {
        heapify(tree,n,i);
    }
}

至此我们有了建堆方法，就终于可以完成堆排序了。

4.堆排序

下面进行堆排序，我们只需要调用建堆的方法即可。然后注意：排升序要建大堆；排降序要建小堆。下面是heapSort()代码的实现：

private static void heapSort(int[] tree, int n){
    // 1. 建堆
    buildHeap(tree,n);
    // 2. 交换堆顶元素tree[0]和最后一个元素tree[i]
    //    交换结束后[0,i)是无序区间 [i,n)是有序区间
    for(int i = n - 1; i >= 0; i--) {
        swap(tree, i, 0);
        // 3. 交换结束后, [0,i)的区间符合heapify条件
        heapify(tree, i, 0);
    }
}

最后完整的完成一下堆排序的代码

public class HeapSort {
    public static void main(String[] args) {
        int[] tree = new int[]{5, 4, 8, 1, 9, 15, 3};
        int n = 7;
        heapSort(tree, n);
        for(int i = 0; i < n; i++){
            System.out.print(tree[i] +" ");
        }
    }
	// heapify() 对保证所有子树都是堆的节点(i)实现堆化
    private static void heapify(int[] tree, int n, int i){
        int c1 = 2*i+1;
        int c2 = 2*i+2;
        // 1. 找出i, c1, c2中的最大值(确保c1, c2存在)
        int max = i;
        if(c1 < n && tree[c1] > tree[max]) {
            max = c1;
        }
        if(c2 < n && tree[c2] > tree[max]) {
            max = c2;
        }
        // 2. 如果 max 不是 i ，则交换 max 与 i 的位置
        if(max != i) {
            swap(tree, max, i);
            // 3. 对max节点递归做heapify.
            heapify(tree, n, max);
        }
    }

    private static void swap(int[] tree, int i, int j) {
        int temp = tree[i];
        tree[i] = tree[j];
        tree[j] = temp;
    }

    // 从最后一个非叶子节点开始，循环使用heapify()函数建堆
    private static void buildHeap(int[] tree, int n) {
        // 1. 找到最后一个非叶子节点
        int lastNode = n - 1;
        int pLastNode = (lastNode-1) / 2;
        // 2. 从最后一个非叶子节点开始，循环使用heapify
        for(int i = pLastNode; i >= 0; i--) {
            heapify(tree,n,i);
        }
    }

    private static void heapSort(int[] tree, int n){
        // 1. 建堆
        buildHeap(tree,n);
        // 2. 交换堆顶元素tree[0]和最后一个元素tree[i]
        //    交换结束后[0,i)是无序区间 [i,n)是有序区间
        for(int i = n - 1; i >= 0; i--) {
            swap(tree, i, 0);
            // 3. 交换结束后, [0,i)的区间符合heapify条件
            heapify(tree, i, 0);
        }
    }
}