java 数据结构 最大堆

package sort;

import java.util.Arrays;

public class MaxHeap<T> {
    private T[] arr;
    private int count;
    private int heapCapacity;

    public MaxHeap()
    {
        heapCapacity=64;
        count =0;
        arr = (T[]) new Object[heapCapacity];
    }

    public MaxHeap(T[] tin)
    {
        heapCapacity=tin.length+1;
        count =tin.length;
        arr = (T[]) new Object[heapCapacity];
        System.arraycopy(tin,0,arr,1,count);
        for (int i = count/2; i >0 ; i--) {
            shiftDown(i);
        }
    }

    public MaxHeap(int capacity)
    {
        heapCapacity=capacity;
        count =0;
        arr = (T[]) new Object[capacity];
    }

    public boolean compare(T object,T valueOfZNode){
        //最大堆和最小堆 可以直接修改该方法实现
        if((object instanceof Integer)){
            return (Integer)object<=(Integer)valueOfZNode;
        }else if(object instanceof Double){
            return (Double)object<=(Double) valueOfZNode;
        }else{
            return false;
        }
    }

    public void insert(T t)
    {
        doubleCapacity();
        arr[++count] = t;
        shiftUp(count);
    }

    public T pop()
    {
        T t= arr[1];
        arr[1]=arr[count--];
        shiftDown(1);
        return t;
    }

    private void shiftUp(int k)
    {
        while(k>1 && !compare(arr[k],arr[k/2]))
        {
            arr[0]=arr[k];
            arr[k]=arr[k/2];
            arr[k/2]=arr[0];
            k/=2;
        }
    }

    public void shiftDown(int k)
    {
        while (k*2<=count)
        {
            if(!compare(arr[k],arr[k*2]))
            {
                break;
            }
            if(k*2 == count)
            {
                arr[0]=arr[k];
                arr[k]=arr[k*2];
                arr[k*2]=arr[0];
                break;
            }
            if(!compare(arr[k*2],arr[k*2+1]))
            {
                arr[0]=arr[k];
                arr[k]=arr[k*2];
                arr[k*2]=arr[0];

                k=k*2;
            }
            else
            {
                arr[0]=arr[k];
                arr[k]=arr[k*2+1];
                arr[k*2+1]=arr[0];
                k=k*2+1;
            }

        }
    }

    private void doubleCapacity()
    {
        if(count+1 < heapCapacity) return;
        arr = Arrays.copyOf(arr,2*arr.length);
    }

    public static void main(String[] args)
    {
        Integer[] arrTemp = {1,23,5,45,25,34,15,37,46,6,849,4,57,31,86,74,32,374,498,876,221,334,81,49,39,231,8,2,321,3,51};
        MaxHeap<Integer> maxHeap =new MaxHeap(arrTemp);
        System.out.println(maxHeap.pop());
        System.out.println(maxHeap.pop());
        System.out.println(maxHeap.pop());
        System.out.println(maxHeap.pop());
        System.out.println(maxHeap.pop());
        System.out.println(maxHeap.pop());
        System.out.println(maxHeap.pop());
        System.out.println(maxHeap.pop());
        System.out.println(maxHeap.pop());
        System.out.println(maxHeap.pop());
        System.out.println(maxHeap.pop());
    }


    //完全二叉树的叶子节点为 数组数量/2+1 之后的所有节点
}