/**
 * CSE 373, Spring 2012
 * A generic implementation of a Priority Queue backed by a minimum
 * binary heap.
 */
import java.util.Arrays;
import java.util.NoSuchElementException;


public class BinaryHeap<E extends Comparable<E>> implements PriorityQueue<E> {
	private static final int DEFAULT_CAPACITY = 10;
	private E[] array;
	private int size;
	
	public String toString() {
		return Arrays.toString(array);
	}
	
	public BinaryHeap() {
		array = (E[])(new Comparable[DEFAULT_CAPACITY]);
		size = 0;
	}
	
	@Override
	public void add(E value) {
		size++;

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

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

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

	@Override
	public E remove() {
		E 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).compareTo(getRightChild(index)) > 0) {
				smallerChildIndex = getRightIndex(index);
			}
			
			if (array[index].compareTo(array[smallerChildIndex]) > 0) {
				swap(index, smallerChildIndex);
				index = smallerChildIndex;
			} else {
				break;
			}
		}
	}
	
	private int getParentIndex(int index) {
		return index / 2;
	}
	
	private E 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 E getLeftChild(int index) {
		return array[getLeftIndex(index)];
	}
	
	private E getRightChild(int index) {
		return array[getRightIndex(index)];
	}
	
	private void swap(int i, int j) {
		E temp = array[i];
		array[i] = array[j];
		array[j] = temp;
	}
	
	private void resize() {
		array = Arrays.copyOf(array, size * 2);
	}
}