/**
 * CSE 373, Spring 2011, Jessica Miller
 * A minimum binary heap implementation for PriorityQueue of integers.
 */
import java.util.Arrays;
import java.util.NoSuchElementException;

public class IntBinaryHeap implements IntPriorityQueue {
    private static final int DEFAULT_CAPACITY = 10;
    private int[] array;
    private int size;
    
    public IntBinaryHeap () {
        array = new int[DEFAULT_CAPACITY];
        size = 0;
    }
    
    public void add(int value) {
    	size++;
    	
    	// if our size has grown too large, resize
    	if (size == array.length) {
    		resize();
    	}
    	
    	array[size] = value;
    	bubbleUp();
    }
    
    private void bubbleUp() {
    	int i = size;
    	
    	
    	while (hasParent(i) && parent(i) > array[i]) {
    		swap(i, parentIndex(i));
    		i = parentIndex(i);
    	}
    }
    
    public boolean isEmpty() {
        return size == 0;
    }
    
    public int peek() {
    	if (isEmpty()) {
    		throw new NoSuchElementException();
    	}
    	
    	return array[1];
    }

    public int remove() {
    	int result = peek();
    	array[1] = array[size];
    	array[size] = 0;
    	size--;
    	
    	bubbleDown();
    	
    	return result;
    }
    
    private void bubbleDown() {
    	int i = 1;
    	int minChildIndex;
    	
    	while (hasLeftChild(i)) {
    		minChildIndex = leftIndex(i);
	    	
	    	if (hasRightChild(i) && array[rightIndex(i)] < array[minChildIndex]) {
	    		minChildIndex = rightIndex(i);
	    	}
	    	
	    	if (array[minChildIndex] < array[i]) {
	    		swap(i, minChildIndex);
	    		i = minChildIndex;
	    	} else {
	    		return;
	    	}
    	}
    }
    
    public String toString() {
        return Arrays.toString(array);
    }
    
    private boolean hasParent(int i) {
        return i > 1;
    }
    
    private int leftIndex(int i) {
        return i * 2;
    }
    
    private int rightIndex(int i) {
        return i * 2 + 1;
    }
    
    private boolean hasLeftChild(int i) {
        return leftIndex(i) <= size;
    }
    
    private boolean hasRightChild(int i) {
        return rightIndex(i) <= size;
    }    
    
    private int parent(int i) {
        return array[parentIndex(i)];
    }
    
    private int parentIndex(int i) {
        return i / 2;
    }
    
    private void resize() {
        array = Arrays.copyOf(array, array.length * 2);
    }     
    
    private void swap(int index1, int index2) {
        int tmp = array[index1];
        array[index1] = array[index2];
        array[index2] = tmp;        
    }
}