二叉堆的实现

二叉堆本质上是完全二叉树，分为最大堆和最小堆，二叉堆的根节点称为堆顶。最大堆：任意父节点值大于或等于左右孩子节点的值，堆顶为整个堆的最大元素。最小堆：任意父节点值小于或等于左右孩子节点的值，堆顶为整个堆的最小元素。

二叉堆的存储方式采用顺序存储，设父节点的数组下标为parent，则左孩子的下标2*parent+1，右孩子的下标为2*parent+2。假设孩子节点的下标为child，则父节点的下标为(child-1) / 2。

二叉堆的插入和删除操作事件复杂度为O(logn)（n个节点的完全二叉树的高度为[logn]+1，插入和删除操作的交换次数和高度相关），堆的构建时间复杂度为O(n)。

public class MyBinaryHeap {
    public static void main(String[] args) {
        MyBinaryHeap binaryHeap = new MyBinaryHeap();
        //构造最小堆，数组存储按照二叉树的层序遍历方式存储
        int[] array = {7, 1, 3, 10, 5, 2, 8, 9, 6};
        binaryHeap.buildHeap(array);
        //1 5 2 6 7 3 8 9 10
        binaryHeap.print(array);

        //最小堆的插入,插入元素0，进行‘上升’操作
        array = new int[]{1, 5, 2, 6, 7, 3, 8, 9, 10, 0};
        binaryHeap.upAdjust(array);
        binaryHeap.print(array);

        //最小堆的删除 将最后一个元素替换第一个元素再进行‘下沉’操作
        array = new int[]{10, 5, 2, 6, 7, 3, 8, 9};
        binaryHeap.downAdjust(array, 0, array.length);
        binaryHeap.print(array);
    }

    public void upAdjust(int[] array) {
        int childIndex = array.length - 1;
        int parentIndex = (childIndex - 1) / 2;
        //记录要插入的元素
        int temp = array[childIndex];
        while (childIndex > 0) {
            if (temp > array[parentIndex]) {
                break;
            }
            //无需交换两元素，只需要单向赋值
            array[childIndex] = array[parentIndex];
            //向上重新确定父节点和孩子节点下标
            childIndex = parentIndex;
            parentIndex = (childIndex - 1) / 2;
        }
        //放入最终要插入的位置
        array[childIndex] = temp;
    }

    public void buildHeap(int[] array) {
        //从最后一个非叶子节点开始，array.length - 2 == array.length - 1 - 1为最后一个元素的父节点
        for (int i = (array.length - 2) / 2; i >= 0; i--) {
            downAdjust(array, i, array.length);
        }
    }

    public void downAdjust(int[] array, int parentIndex, int length) {
        //记录的左右孩子节点中值较小的下标，初始值为左孩子下标
        int childIndex = parentIndex * 2 + 1;
        int temp = array[parentIndex];

        while (childIndex < length) {
            if (childIndex + 1 < length && array[childIndex] > array[childIndex + 1]) {
                //右孩子值更小，更改为右孩子下标
                childIndex++;
            }
            if (temp <= array[childIndex]) {
                //父节点的值更大，无需替换
                break;
            }
            //单向赋值
            array[parentIndex] = array[childIndex];
            //向下继续确定父节点和孩子节点
            parentIndex = childIndex;
            childIndex = 2 * parentIndex + 1;
        }
        array[parentIndex] = temp;
    }

    public void print(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }
}

完全二叉树转最小堆：1 5 2 6 7 3 8 9 10 
最小堆插入元素0：0 1 2 6 5 3 8 9 10 7 
最小堆删除堆顶元素：2 5 3 6 7 10 8 9