Rather than inserting your elements directly into the queue, wrap each element in a tuple, where the first element in the tuple is the desired sorting key. Tuples are sorted by in order of their elements (i.e., first element is compared first), hence why the sorting key needs to come first.
I’ll explain the first error to you. At line 331, you’re probably reading an (unsigned) int, in a part of the memory you haven’t allocated for your own program. This part gives more information about the part of memory you tried to read. It says you’ve already used the memory, but reallox freed it. That … Read more
Note – You may also want to check other answers, especially the one with decltype and lambda You should declare a class Compare and overload operator() for it like this: Or, if you for some reasons can’t make it as class, you could use std::function for it:
How about like this: The Collections.reverseOrder() provides a Comparator that would sort the elements in the PriorityQueue in a the oposite order to their natural order in this case.
Below is what I believe to be a truly efficient version of a PriorityQueue which uses an array-based binary heap (where the root is at index 0, and the children of a node at index i are at indices 2i + 1 and 2i + 2, respectively). This implementation includes the classical priority queue methods like push, peek, pop, and size, as well as convenience methods isEmpty and replace (the latter … Read more
Use the constructor overload which takes a Comparator<? super E> comparator and pass in a comparator which compares in the appropriate way for your sort order. If you give an example of how you want to sort, we can provide some sample code to implement the comparator if you’re not sure. (It’s pretty straightforward though.) As has … Read more
If you have an array of size n and you want to build a heap from all items at once, Floyd’s algorithm can do it with O(n) complexity. See Building a heap. This corresponds to the std::priority_queue constructors that accept a container parameter. If you have an empty priority queue to which you want to add n items, one at a time, … Read more
You might like IntervalHeap from the C5 Generic Collection Library. To quote the user guide Class IntervalHeap<T> implements interface IPriorityQueue<T> using an interval heap stored as an array of pairs. The FindMin and FindMax operations, and the indexer’s get-accessor, take time O(1). The DeleteMin, DeleteMax, Add and Update operations, and the indexer’s set-accessor, take time O(log n). In contrast to an ordinary priority queue, an interval heap … Read more
Regarding std::priority_queue: A user-provided Compare can be supplied to change the ordering, e.g. using std::greater<T> would cause the smallest element to appear as the top(). Since std::less<T> is the default template argument to the Compare template parameter, it is already a max heap by default. If you want a min heap instead (what the quote above suggest), pass std::greater<T> instead of std::less<T> as the template argument. To summarize: Max Heap: pass std::less<T> (this is the default template … Read more
Add() works like an insertWithPriority. You can define priority for the type that you want using the constructor: look under https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/PriorityQueue.html The order the Comparator gives will represent the priority in the queue.