最大堆构建和堆排序

1 输入一个任意长度的无规律数组，把该数组构建为最大堆

2 用构建好的最大堆，进行堆排序

public class Solution {
    
    /**
     * 构建堆
     * @param array
     */
    public static void buildMaxHeap(int[] array) {
        
    /*    for (int i = array.length / 2; i >= 0; i--) {
            adjust(array, i, array.length);    
        }*/
        /** 以树的最后一个节点的父节点为根开始调整  */
        int last = array.length - 1;
        int pos = (last - 1) / 2;
        while (pos >= 0) {
            adjust(array, pos--, array.length);
        }
    }
    
    
    /**
     * 把以root为根的那棵子树调整为最大堆, 此时以root为根的左右子树都以调整为最大堆
     * @param array
     * @param root
     * @param len
     */
    public static void adjust(int[] array, int root, int len) {
        int l = root * 2 + 1;
        int r = root * 2 + 2;
        int largest = root;
        
        /** 特别要考虑满二叉树的情况 */
        //parent节点有左孩子
        if (l < len && array[l] > array[largest]) {
                largest = l;
        }
        //parent节点有右孩子
        if (r < len && array[r] > array[largest]) {
                largest = r;
        }
        
        //如果以root为根的堆
        if (largest != root) {
            swap(array, root, largest);
            adjust(array, largest, len);
        }
    }
    
    
    /**
     *  堆排序函数
     * @param array
     * @param len
     */
    public static void heapSort(int[] array) {
        
        int len = array.length;
        
        while (len > 1) {
            /** 堆顶的元素为数组中所有元素的最大值
                                出堆顶，把堆对应树的最后那个节点放到堆顶（从堆顶向下调整）
                                此时，堆对应树的最后那个节点位置为空，把刚出的堆顶最大值放入该空位 */
            swap(array, 0, len - 1); //拿堆对应的树的最后一个节点与根节点交换
            len--;
            adjust(array, 0, len);
        }
    }
    
    public static void print(int[] array) {
        for (int i = 0; i < array.length;  i++) {
            System.out.println(i + ", " + array[i]);
        }
    }
    
    public static void swap(int[] array, int t1, int t2) {
        int temp = array[t1];
        array[t1] = array[t2];
        array[t2] = temp;
    }
    
    
    
    public static void main(String[] args) {
        
        //生成随机数数组
        int[] array = { 53, 17, 78, 9, 45, 65, 87};
        
        buildMaxHeap(array);
        System.out.println("建堆完成：");
        print(array);
        System.out.println("------------------");
        
        heapSort(array);
        print(array);
    }
}

 上述方案调整堆的原理为：

    1）叶子节点，无子树，可以把叶结点看作为一棵树，为最大堆

    2）从最后一个叶节点开始

    3）让pos指向该叶结点的父节点，pos指向一个子树，其孩子（为叶结点）已是最大堆，然后我们只要把这棵树调整为最大堆

    4）pos减1，走3），直到pos指向数组索引0处，把堆顶调整完成