public BinaryHeap(E[] data, Comparator<? super E> c) { super(data.length); size = 0; for (final E val : data) { if (val != null) setUngaurded(size++, val); } comparator = c; heapify(); assert check(); }
public BinaryHeap(Collection<? extends E> data, Comparator<? super E> c) { super(data.size()); size = 0; for (final E val : data) { if (val != null) setUngaurded(size++, val); } comparator = c; heapify(); assert check(); }
public E remove() { if (size < 1) return null; // underflow final E value = get(0); if (size == 1) { // it is last element set(--size, null); } else { set(0, get(--size)); set(size, null); heapify(0); } assert check(); return value; }
private void heapify(int i) { assert (i < size); if (i < 0) return; final int l = left(i); final int r = right(i); int largest = i; if (l < size && comparator.compare(get(l), get(largest)) > 0) { largest = l; } if (r < size && comparator.compare(get(r), get(largest)) > 0) { largest = r; } if (largest != i) { final E tmp = get(i); set(i, get(largest)); set(largest, tmp); heapify(largest); } }
public void sort() { final int sizeBackup = size; while (size > 1) { // swap element(0) and element(size-1) final E tmp = get(--size); set(size, get(0)); set(0, tmp); heapify(0); } // restore size size = sizeBackup; // reverse the store so that it is sorted as well as valid heap; // e.g. a sorted array in decreasing order is a valid max heap. for (int i = 0, j = size - 1; i < j; i++, j--) { final E tmp = get(i); set(i, get(j)); set(j, tmp); } }
private void heapify() { for (int i = size / 2 - 1; i >= 0; i--) { heapify(i); } }