@Override public boolean remove(E value) { if (value == null) return false; else return this.delegate.remove(this.getWrappedEntry(value)); }
private void testRemoveAndAdd_HigherPriority(MinHeap<HasIndex> pq) { DummyHeapEntry entry0 = new DummyHeapEntry(5); DummyHeapEntry entry1 = new DummyHeapEntry(3); DummyHeapEntry entry2 = new DummyHeapEntry(6); pq.add(entry0, 5.0); pq.add(entry1, 3.0); pq.add(entry2, 6.0); Assert.assertEquals(3, pq.size()); // test removing an element and adding it with higher priority (=lower value) pq.remove(entry0); Assert.assertEquals(2, pq.size()); pq.add(entry0, 2.5); Assert.assertEquals(3, pq.size()); assertEqualsHE(entry0, pq.poll()); assertEqualsHE(entry1, pq.poll()); assertEqualsHE(entry2, pq.poll()); Assert.assertNull(pq.poll()); }
private void testOddOrder(MinHeap<HasIndex> pq) { DummyHeapEntry entry0 = new DummyHeapEntry(0); DummyHeapEntry entry1 = new DummyHeapEntry(1); DummyHeapEntry entry2 = new DummyHeapEntry(2); DummyHeapEntry entry3 = new DummyHeapEntry(3); pq.add(entry0, 0.0); pq.add(entry3, 3.0); pq.add(entry1, 1.0); pq.add(entry2, 2.0); assertEqualsHE(entry0, pq.poll()); assertEqualsHE(entry1, pq.poll()); assertEqualsHE(entry2, pq.poll()); assertEqualsHE(entry3, pq.poll()); Assert.assertNull(pq.poll()); }
private void testAdd(MinHeap<HasIndex> pq) { DummyHeapEntry entry0 = new DummyHeapEntry(5); DummyHeapEntry entry1 = new DummyHeapEntry(3); DummyHeapEntry entry2 = new DummyHeapEntry(6); Assert.assertEquals(0, pq.size()); pq.add(entry0, 1.0); Assert.assertEquals(1, pq.size()); pq.add(entry1, 2.0); Assert.assertEquals(2, pq.size()); pq.add(entry2, 2.0); // different element with same priority Assert.assertEquals(3, pq.size()); pq.add(entry2, 3.0); // same element with different priority Assert.assertEquals(3, pq.size()); // should not be added! Assert.assertEquals(3, iteratorElementCount(pq.iterator())); }
private void testIterator(MinHeap<HasIndex> pq) { DummyHeapEntry entry0 = new DummyHeapEntry(5); DummyHeapEntry entry1 = new DummyHeapEntry(3); DummyHeapEntry entry2 = new DummyHeapEntry(6); DummyHeapEntry entry3 = new DummyHeapEntry(4); pq.add(entry0, 5.0); pq.add(entry1, 3.0); pq.add(entry2, 6.0); Collection<?> coll = getIteratorCollection(pq.iterator()); Assert.assertEquals(3, coll.size()); Assert.assertTrue(coll.contains(entry0)); Assert.assertTrue(coll.contains(entry1)); Assert.assertTrue(coll.contains(entry2)); Assert.assertFalse(coll.contains(entry3)); }
private MinHeap<HasIndex> createMinHeap(boolean classicalRemove) { MinHeap<HasIndex> pq = new BinaryMinHeap<HasIndex>(maxElements, BinaryMinHeap.defaultFanout, classicalRemove); return pq; }
@Override public Iterator<E> iterator() { return new ArrayIterator(this.delegate.iterator()); }
private void siftDownUp(int index) { index = removeSiftDown(index); // Swap entry with heap's last entry. heapSize--; // Sift up entry that was previously at the heap's end. siftUp(index, data[heapSize], costs[heapSize]); // Reset sentinel here: costs[heapSize] = Double.MAX_VALUE; }
@Override public boolean add(E value, double priority) { return this.delegate.add(this.getOrCreateWrappedEntry(value), priority); }
@Override public boolean decreaseKey(E value, double priority) { return this.delegate.decreaseKey(this.getWrappedEntry(value), priority); }
private WrappedEntry getOrCreateWrappedEntry(E value) { WrappedEntry wrappedEntry = this.getWrappedEntry(value); if (wrappedEntry == null) { int index = map.size(); // if (index > maxSize) throw new RuntimeException("Number of elements exceeds the number of specified elements."); wrappedEntry = new WrappedEntry(value, index); map.put(value, wrappedEntry); } return wrappedEntry; }
private MinHeap<HasIndex> createWrappedMinHeap(boolean classicalRemove) { MinHeap<HasIndex> pq = new WrappedBinaryMinHeap<HasIndex>(maxElements, BinaryMinHeap.defaultFanout, classicalRemove); return pq; }
@Override public void reset() { // I don't see why we need this? Might make sense if after a reset are added new elements - // but in that case create a new heap. // cdobler, sep'17 // this.map.clear(); this.delegate.reset(); }
/** * Returns an iterator over the elements in this queue. The iterator * does NOT return the elements sorted by their priority. However, * their order should be deterministic since the underlying array is. * Removing elements is not supported via the iterator. * * @return an iterator over the elements in this queue. */ @Override public Iterator<E> iterator() { return new ArrayIterator(data, heapSize); }
@Override public boolean isEmpty() { return this.delegate.isEmpty(); }
private void copyData(int indexTarget, int indexSource) { // copy HeapEntries E entry = data[indexSource]; data[indexTarget] = entry; // copy costs costs[indexTarget] = costs[indexSource]; // copy indices indices[this.getIndex(entry)] = indexTarget; }
@Override public int size() { return this.delegate.size(); }