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