二叉堆实现

最大堆：父结点的键值总是大于或等于任何一个子节点的键值；如下图左

最小堆：父结点的键值总是小于或等于任何一个子节点的键值。如下图右

public class Test {
    public static void main(String []args){
        MaxHeap mh = new MaxHeap(20);
        mh.insert(90);
        mh.insert(80);
        mh.insert(89);
        mh.insert(60);
        mh.insert(40);
        mh.insert(88);
        mh.insert(87);
        mh.insert(10);
        mh.insert(50);
        mh.insert(30);
        mh.insert(20);
        mh.insert(86);
        mh.printHeap();
        System.out.println("===================");
        System.out.println(mh.remove(60));
        mh.printHeap();
    }
}

class MaxHeap{
    public MaxHeap(int capacity){
        this.capacity = capacity;  //数组实际大小
        this.size = 0;             //数组中现有元素个数
        this.items = new int[capacity];
    }


     //获取指定元素所在下标
    public int getIndex(int item){
        //如果数据量为0或者所找的数比最大堆的堆顶大，则返回-1，即数组中不存在所查元素
        if(size == 0 || item > items[0]){
            return -1;
        }

        //遍历查找
        for(int i = 0; i < size; i++){
            if(item == items[i]){
                return i;
            }
        }
        return -1;
    }

    public boolean insert(int item){
        if(size == capacity){
            return false;
        }
        items[size++] = item;
        //每次插入时堆已经有序，只需将最新插入的元素向上移动
        upAdjust(size - 1);
        return true;
    }

    public boolean remove(int item){
        int index = getIndex(item);
        if(index != -1){
            items[index] = items[--size];
            /*
            *删除某个元素是向上调整和向下调整是必须都要执行的
            *从数组[90, 80, 89, 60, 40, 88, 87, 10, 50, 30, 20, 86]可以看出
            * 如果删除60，只进行向下调整会破坏最大堆的性质
            * 加upAdujst时的结果:  [90, 86, 89, 80, 40, 88, 87, 10, 50, 30, 20]
            * 不加upAdujst时的结果:[90, 80, 89, 86, 40, 88, 87, 10, 50, 30, 20]
             */
            downAdjust(index);
            upAdjust(index);
            return true;
        }
        return false;
    }

    public void printHeap(){
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        for(int i = 0; i < size; i++){
            sb.append(items[i] + ", ");
        }
        sb.replace(sb.length() - 2, sb.length(), "]");
        System.out.println(sb.toString());
    }

    private void upAdjust(int index){
        int childIndex = index;
        int parentIndex = (childIndex - 1) / 2;
        int temp = items[childIndex];

        while(childIndex > 0 && temp > items[parentIndex]){
            items[childIndex] = items[parentIndex];
            childIndex = parentIndex;
            parentIndex = (parentIndex - 1) / 2;
        }
        items[childIndex] = temp;
    }

    private void downAdjust(int index){
        int parentIndex = index;
        int childIndex = parentIndex * 2 + 1;
        int temp = items[index];

        while(childIndex < size && temp < items[childIndex]){
            if(childIndex + 1 < size && items[childIndex] < items[childIndex + 1]){
                childIndex++;
            }
            items[parentIndex] = items[childIndex];
            parentIndex = childIndex;
            childIndex = (parentIndex - 1) / 2;
        }
        items[parentIndex] = temp;
    }

    private int[] items;
    private int capacity;
    private int size;
}