/**
 * CSE 373, Spring 2012
 * 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 String toString() {
		return Arrays.toString(array);
	}
	
	public IntBinaryHeap() {
		array = new int[DEFAULT_CAPACITY];
		size = 0;
	}
	
	@Override
	public void add(int value) {
		size++;

		if (size == array.length) {
			resize();
		}
		
		array[size] = value;
		bubbleUp();
	}
	
	private void bubbleUp() {
		int index = size;
		
		while (hasParent(index) && getParent(index) > array[index]) {
			swap(getParentIndex(index), index);
			index = getParentIndex(index);
		}
	}
	
	private boolean hasParent(int index) {
		return index > 1;
	}

	@Override
	public boolean isEmpty() {
		return size == 0;
	}

	@Override
	public int peek() {
		if (isEmpty()) {
			throw new NoSuchElementException();
		}
		
		return array[1];
	}

	@Override
	public int remove() {
		int min = peek();
		array[1] = array[size];
		size--;
		bubbleDown();
		return min;
	}
	
	private void bubbleDown() {
		int index = 1;
		
		while (hasLeftChild(index)) {
			int smallerChildIndex = getLeftIndex(index);
			
			if (hasRightChild(index) &&
				getLeftChild(index) > getRightChild(index)) {
				smallerChildIndex = getRightIndex(index);
			}
			
			if (array[index] > array[smallerChildIndex]) {
				swap(index, smallerChildIndex);
				index = smallerChildIndex;
			} else {
				break;
			}
		}
	}
	
	private int getParentIndex(int index) {
		return index / 2;
	}
	
	private int getParent(int index) {
		return array[getParentIndex(index)];
	}
	
	private int getLeftIndex(int index) {
		return index * 2;
	}

	private int getRightIndex(int index) {
		return index * 2 + 1;
	}

	private boolean hasLeftChild(int index) {
		return getLeftIndex(index) <= size;
	}

	private boolean hasRightChild(int index) {
		return getRightIndex(index) <= size;
	}

	private int getLeftChild(int index) {
		return array[getLeftIndex(index)];
	}
	
	private int getRightChild(int index) {
		return array[getRightIndex(index)];
	}
	
	private void swap(int i, int j) {
		int temp = array[i];
		array[i] = array[j];
		array[j] = temp;
	}
	
	private void resize() {
		array = Arrays.copyOf(array, size * 2);
	}
}