The speaker is wrong in this case. The actual cost is O(n * log(t)). Heapify is called only on the first t elements of the iterable. That’s O(t), but is insignificant if t is much smaller than n. Then all the remaining elements are added to this “little heap” via heappushpop, one at a time. … Read more
How can you say Lucene’s doesn’t support a custom comparator? Its abstract and you must implement the abstract method lessThan(T a, T b)
To implement “decrease-key” effectively, you’d need to access the functionality “decrement this element AND swap this element with a child until heap condition is restore”. In heapq.py, that’s called _siftdown (and similarly _siftup for INcrementing). So the good news is that the functions are there… the bad news is that their names start with an … Read more
There’s no difference in terms of performance. std::priority_queue is just an adapter class that wraps the container and the very same heap-related function calls into a class. The specification of the std::priority_queue openly states that. By building a heap from an exposed std::vector and calling heap-related functions directly, you keep it open to the possibility … Read more
You would use a min-max-median heap to find the min, max and median in constant time (and take linear time to build the heap). You can use order-statistics trees to find the kth smallest/largest value. Both of these data structures are described in this paper on min-max heaps [PDF]. Min-max heaps are binary heaps that … Read more
Nothing much, to be honest. I would imagine that the word heap was simply taken with it’s everday (non-technical) usage and applied to these two concepts individually as reasonably good analogies. In the first case (tree data structure meaning), the description heap is most appropiate because “greater” objects are placed higher up in the tree … Read more
There’s no reason why a heap implemented in an array has to leave the item at index 0 unused. If you put the root at 0, then the item at array[index] has its children at array[index*2+1] and array[index*2+2]. The node at array[child] has its parent at array[(child-1)/2]. Let’s see. root at 0 root at 1 … Read more
You can do following: store a hashmap inside your heap that maps your heap values to heap indexes. Then you should extend your usual heap-logic just a bit: on Swap(i, j): map[value[i]] = j; map[value[j]] = i; on Insert(key, value): map.Add(value, heapSize) in the beginning; on ExtractMin: map.Remove(extractedValue) in the end; on UpdateKey(value, newKey): index … Read more
Yes, you can make this assumption, because it is stated in the documentation: Heaps are arrays for which heap[k] <= heap[2*k+1] and heap[k] <= heap[2*k+2] for all k, counting elements from zero. For the sake of comparison, non-existing elements are considered to be infinite. The interesting property of a heap is that heap[0] is always … Read more
Actually, you can remove an item from the middle of a heap without trouble. The idea is to take the last item in the heap and, starting from the current position (i.e. the position that held the item you deleted), sift it up if the new item is greater than the parent of the old … Read more