dataStructure@ Implementation of minimal heap

package data_structure_testing;

import java.util.ArrayList;
import java.util.HashSet;

public class MinHeap {

    public ArrayList<Integer> minheap = null;
    
    public MinHeap() {    
        this.minheap = new ArrayList<Integer> ();
        this.minheap.add(Integer.MIN_VALUE);
        /**
         * -------------------------------------------------------------------------
         * Integer.MIN_VALUE |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
         * -------------------------------------------------------------------------
         */
    }
    
    public void swap(int i, int j) {
        if(i == j)  return;
        int tmp = minheap.get(i);
        minheap.set(i, minheap.get(j));
        minheap.set(j, tmp);
    }
    
    public int getSize() {
        return minheap.size();
    }
    
    public int parent(int i) {
        return i/2;
    }
    
    public int leftChild(int i) {
        return i*2;
    }
    
    public int rightChild(int i) {
        return i*2 + 1;
    }
    
    public void offer(int x) {
        
        minheap.add(x);
        int position = minheap.size() - 1;
        bubbleUp(position);
    }
    
    public void bubbleUp(int position) {
        
        int pa = parent(position);
        if(pa != 0 && minheap.get(position) < minheap.get(pa)) {
            swap(position, pa);
            bubbleUp(pa);
        }
    }
    
    public int peek() {
        if(getSize() == 1) {
            System.out.println("the min heap is empty!");
            return minheap.get(0);
        } else{
            return minheap.get(1);
        }
    }
    
    public void pushDown(int i) {
        
        int min_position = i, min_value = minheap.get(i);
        int lc = leftChild(i), rc = lc + 1;
        
        if(lc >= getSize()) {
            return;
        }
        
        if(lc < getSize()) {
            if(minheap.get(lc) < min_value) {
                min_position = lc;
                min_value = minheap.get(lc);
            }
            if(rc < getSize() && minheap.get(rc) < min_value) {
                min_position = rc;
            }
        }
        
        swap(min_position, i);
        if(min_position != i) {
            pushDown(min_position);
        }
    }
    
    public int poll() {
        if(getSize() == 1) {
            System.out.println("since the min heap is empty, so we cannot poll any element from it!");
            return minheap.get(0);
        }
        
        int top = minheap.get(1);
        swap(1, getSize()-1);
        minheap.remove(getSize()-1);
        
        if(getSize() > 1) {
            pushDown(1);
        }
        
        return top;
    }
    
    public static void main(String[] args) {
        
        MinHeap minheap = new MinHeap();
        
        minheap.offer(5);
        minheap.offer(4);
        minheap.offer(2);
        minheap.offer(4);
        minheap.offer(3);
        
        System.out.println(minheap.poll());
        System.out.println(minheap.poll());
        System.out.println(minheap.poll());
        System.out.println(minheap.poll());
        System.out.println(minheap.poll());
        System.out.println(minheap.poll());

    }

}