priority-queue | A priority queue for Rust with efficient change function | Hashing library

This was not possible due to several issues in numba, but should be fixed for the next release (0.55) if I understood correctly. As a workaround for now, I could get it working by compiling llvmlite 0.38.0dev0 and the master branch of numba. I do not use conda but it is apparently easier to get pre-releases of llvmlite and numba this way.

Here is my implementation:

As per the documentation of the crate (package).

I believe you should be using DoublePriorityQueue instead of PriorityQueue as it offers to peek in the queue the highest value or the lowest. Using peek_max or peek_min respectively.

See the snippet of code they provide in the documentation:

The type of the value of the key items inside the dict is list so you can manipulate it using list comprehension. For example -

I'm trying to understand the code below from

Let's say in points:

• .* is pointer-to-member access operator. See https://en.cppreference.com/w/cpp/language/operator_member_access
• The code is using internal representation of the priority_queue, it's using the underlying container used by the queue to store data and accessing that data using protected member with the name c.

  • From glibc stl_queue.h:

It is not entirely clear, but I think your problem is caused by an incorrect implementation of compareTo.

Heap insertion and extraction have the worst case complexity relative to the height of the tree, thus O(log N), plus the complexity of the underlying data structure.

In case of a vector, push_back has an amortized complexity O(1), and pop_back O(1).

Therefore it can be said that the total time complexity of push and pop of a priority_queue backed by a vector is O(log N).

I also tried with multiple io_context but it adds additional complexities.

I think this is a basic misconception: it doesn't actually (as long as you don't explicitly bind handlers to executors from a different execution context, perhaps. But such a thing is hard to do accidentally).

Now if the requirement is:

For e.g. I have 2 HTTP connections open with server then one connection should always be available to push high priority data to server and where as the other connection can be used for pushing rest of stuff.

Then the answer is you can all that without using multiple threads at all. If you appear to require threads still, this indicates that you're performing longer running tasks inside handlers (blocking the io thread(s)).

Indeed in such case you may indeed want to have a dedicated execution context that is being run on a separate thread(s).

The simplest solution given your pre-existing situation would be to, indeed, have a second io_context that you run from its own thread.

My more common guideline would be the inverse: prevent the situation you have by never executing any blocking tasks on the UI thread. This leads to a design where I have only one IO thread usually, and the actual work gets put on task queues that can be serviced from a thread pool. Only when the task ready to send a response, they will post their IO operation to the IO context.

As you probably know complexity is easier to prevent than it is to achieve simplicity after-the-fact.

Use the heap-based algorithm for finding the k largest value, i.e. use a min heap (not a max heap) that never exceeds a size of k. Once it exceeds that size, keep pulling the root from it to restore it to a size of k.

At the end the heap's root will be k largest value. Let's call it m.

You could then scan the original input again to collect all values that are at least equal to m. This way you'll have them in their original order.

When that m is not unique, you could have collected too many values. So check the size of the result and determine how much longer it is than k. Go backwards through that list and mark the ones that have value m as deleted until you have reached the right size. Finally collect the non-deleted items.

All these scans are O(n). The most expensive step is the first one: O(nlogk).

Maps use the default constructor when creating new elements. You could use pointers, but you’d need to allocate each new entry: