implement min heap

class MinHeap{
    private ArrayList<Integer> arr;
    private int DEFAULT_LEN = 10;
    public MinHeap(){
        arr = new ArrayList<Integer>(DEFAULT_LEN);
    }

//Use an existing array to build min heap
    public MinHeap(ArrayList<Integer> input){
        this.arr = input;
        buildMinHeap();
    }
    
    public MinHeap(int[] input){
        arr = new ArrayList<Integer>();
        for(int i = 0; i < input.length; i ++){
            arr.add(input[i]);
        }
        buildMinHeap();
    }

//由于需要维持完全二叉树的形态，需要先将要插入的结点x放在最底层的最右边，插入后满 足完全二叉树的特点； 
//然后把x依次向上调整到合适位置满足堆的性质.
//时间：O(logn)。  “结点上浮” 
    public void insert(int val){//bot - top
        arr.add(val);
        botupModifyHeap(arr.size() - 1);
    }

//当删除顶点的数值时，原来的位置就会出现一个孔,填充这个孔的方法就是， 
//把最后的叶子的值赋给该孔并下调到合适位置，然后该叶子删除。 
    public int deleteTop(){//top - bot
        int result = arr.get(0);
        arr.set(0, arr.get(arr.size() - 1));
        arr.remove(arr.size() - 1);
        upbotModifyHeap(0);
        return result;
    }

    public int swapTop(int val){
        int result = arr.get(0);
        arr.set(0, val);
        upbotModifyHeap(0);
        return result;
    }

    @Override
    public String toString(){
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < arr.size(); i ++){
            sb.append(arr.get(i) + " ");
        }
        return sb.toString();
    }


    private void buildMinHeap(){
        for(int i = arr.size() / 2 - 1; i > -1; i --){//bottom-up build min heap
            upbotModifyHeap(i);
        }
    }

    private void upbotModifyHeap(int curIndex){//top-bot modify min heap
        int left = curIndex * 2 + 1;
        int right = curIndex * 2 + 2;
        int smallest = curIndex;
        if(left < arr.size() && arr.get(left) < arr.get(smallest))
            smallest = left;
        if(right < arr.size() && arr.get(right) < arr.get(smallest))
            smallest = right;
        if(smallest != curIndex){
            swap( smallest, curIndex);
            upbotModifyHeap(smallest);
        }
    }

    private void botupModifyHeap(int curIndex){//bottom-up modify min heap
        if(curIndex == 0) return;
        int parentIndex = curIndex / 2;
        if(arr.get(parentIndex) > arr.get(curIndex)){
            swap(parentIndex,curIndex);
            botupModifyHeap(parentIndex);
        }
    }

    private void swap(int aa, int bb){
        int tmp = arr.get(aa);
        arr.set(aa, arr.get(bb));
        arr.set(bb, tmp);
    }
}

Test case:

int[] input = new int[]{7,8,9,10,11,12};

MinHeap minHeap = new MinHeap(input);
//        System.out.println(minHeap);
        for(int i = 0; i < input.length; i ++){
            minHeap.insert(i + 1);
            System.out.print(minHeap.deleteTop() + " ");
        }
        for(int i = 0; i < input.length; i ++){
            System.out.print(minHeap.deleteTop() + " ");
        }



Output:
1 2 3 4 5 6 7 8 9 10 11 12 

        MinHeap m2 = new MinHeap();
        int[] i2 = new int[]{4,7,9,3,6,5,1,2,8};
        for(int i = 0; i < i2.length; i ++)
            m2.insert(i2[i]);
        for(int i = 0; i < i2.length; i ++)
            System.out.print(m2.deleteTop() + " ");


Output:
1 2 3 4 5 6 7 8 9