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);
}
}
