As you discovered, a priority queue does not resort all elements whenever an element is added or removed. Doing that would be too expensive (remember the n log n lower bound for comparison sort), while any reasonable priority queue implementation (including PriorityQueue) promises to add/remove nodes in O(log n). In fact, it doesn’t sort its … Read more
This is what priority_queue looks like: template< class T, class Container = std::vector<T>, class Compare = std::less<typename Container::value_type> > class priority_queue; In other words, CompareDist should be the third argument and the second argument should be the container (which has value_type), like the following: priority_queue<pair<int,int>,vector<pair<int,int>>,CompareDist> pq; Notice also, that priority_queue is what is called a … Read more
In the past I have simply used sortedcontainers’s SortedList for this, as: > a = SortedList() > a.add(3) > a.add(2) > a.add(1) > a.pop() 3 It’s not a heap, but it’s fast and works directly as required. If you absolutely need it to be a heap, you could make a general negation class to hold … Read more
The logical argument is as follows std::priority_queue is a container adaptor; basic memory considerations make the back the preferred place for modifications (with pop_back() and push_back()) for sequence containers such as std::vector. the priority_queue primitives are based on std::make_heap (constructor), std::pop_heap + container::pop_back (priority_queue::pop) and on container::push_back + std::push_heap (priority_queue::push) pop_heap will take the front … Read more
I guess you expect PriorityQueue to return elements in particular order when you iterate it. However, PriorityQueue doesn’t provide such a behaviour, because it’s implemented as a priority heap rather than sorted list. From javadoc: The Iterator provided in method iterator() is not guaranteed to traverse the elements of the priority queue in any particular … Read more
Testing is the best way to answer this question for your specific computer architecture, compiler, and implementation. Beyond that, there are generalizations. First off, priority queues are not necessarily O(n log n). If you have integer data, there are priority queues which work in O(1) time. Beucher and Meyer’s 1992 publication “The morphological approach to … Read more
You might need to implement such a heap yourself. You need to have some handle to the position of the item in the heap, and some methods to push the item up or down when its priority has changed. Some years ago I wrote such a heap as part of a school work. Pushing an … Read more
The priority queue adaptor uses the standard library heap algorithms to build and access the queue – it’s the complexity of those algorithms you should be looking up in the documentation. The top() operation is obviously O(1) but presumably you want to pop() the heap after calling it which (according to Josuttis) is O(2*log(N)) and … Read more
Typical Solution The usual solution is to mark an element as invalid and insert a new element, then eliminate the invalid entries as they are popped-off. Alternative Solution If that approach doesn’t suffice, it is possible restore the min-heap invariant in O(log n) steps as long as the location of the value being changed is … Read more
I can suggest 2 choices to solve the problem, although neither performs a real update. Use the priority_queue and push element each time you would like to update it. Accept the fact that you will have useless entries in the queue. When popping the top value, check if it contains the up-to-date value. If not, … Read more