完全二叉树与数组

完全二叉树可以理解为数组，在数组中某个元素在二叉树中的左孩子为2*i+1，右孩子为2*i+2，（i为该元素的索引），一个元素的父节点为 (i-1)/2 

大根堆：父节点大于孩子节点的完全二叉树。

小根堆：父节点小于孩子节点的完全二叉树。

由于将一个元素插入到完全二叉树中时至于其父元素进行比较，比较次数为二叉树的高度，因此其调整代价为，当加入第i个节点时，前面i-1个节点已经形成完全二叉树，因此其调整代价为，i+1个为，所以N个节点调整代价为

一个大根堆的元素被改变时，将其与左右孩子节点中的最大值进行比较，如果小于孩子节点的值，者将其与孩子节点最大值交换，循环到叶子节点可重新得到大根堆。

public class BigTree {

    public static int[] creatArr() {
        // 生成长度随机的数组
        int[] arr = new int[(int) (Math.random() * 100)];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 100 - Math.random() * 59);
        }
        heapSort(arr);
        return arr;
    }

    public static void heapSort(int[] arr) {
        if (null == arr || arr.length < 2) {
            return;
        }
        for (int i = 0; i < arr.length; i++) {
            heapBigSort(arr, i);
        }
        int heapRight = arr.length;
        /*
         *以下是利用大根堆堆数组进行排序
         * 并重新调整大根堆
         *
         *将堆的第一个元素与最后一个元素交换，得到最后一个数是最大值的堆
         *然后将数组有边界减一，因为最后一个元素已经是最大值
         */
        huan(arr, 0, --heapRight);
        while (heapRight > 0) {
            doBigHeadle(arr, 0, --heapRight);
            huan(arr, 0, heapRight);
        }

    }

    //将第一个元素是最小值的堆调整为大根堆
    public static void doBigHeadle(int[] arr, int L, int R) {

        int leftChild = 2 * L + 1;//左子树索引

        while (leftChild < R) {
            /*
             * 获取左右孩子中值最大的元素的索引，如果leftChild+1（右孩子索引）不小于R（R为数组有边界）,则返回左孩子索引
             */
            leftChild = leftChild + 1 < R ? arr[leftChild] > arr[leftChild + 1] ? leftChild : leftChild + 1 : leftChild;
            /*
             *父节点不小于孩子节点，将跳出循环
             *
             */
            if (arr[L] >= arr[leftChild]) {
                break;
            }
            huan(arr, leftChild, L);
            L = leftChild;
            leftChild = leftChild * 2 + 1;
        }


    }

    /**
     * 将数组调整为大根堆
     *
     * @param arr
     * @param index
     */
    public static void heapBigSort(int arr[], int index) {

        while (arr[index] > arr[(index - 1) / 2]) {
            huan(arr, (index - 1) / 2, index);
            index = (index - 1) / 2;
        }

    }


    public static void huan(int[] arr, int bei, int index) {
        int tem = arr[bei];
        arr[bei] = arr[index];
        arr[index] = tem;
    }

    public static void main(String[] args) {
        int[] ints = creatArr();
        for (int i = 0; i < ints.length; i++) {
            System.out.print(ints[i] + " ");
        }
    }
}