priority-q | Priority queue using C | Dictionary library

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:

I understand your question like this (correct me if I'm wrong):

You try to compute Dijkstra for every pair of nodes in a graph. So you have V(V-1)/2 pairs in the graph (V is number of vertices).

Then, V(V-1) (that is O(V^2) times you compute Dijkstra, which has complexity O(V + ElogV) (I don't know where did you get your O(VlogV + E) from, but it's probably incorrect)

Overall, the complexiy is O(V^2logV + EV^2)

As far as I know, when you store things in MongoDB they are stored as extended JSON (EJSON) in binary format (BSON)

it is stored as min heap. read more about min heap

Pretty much.

You can't "sort" a standard queue because it does not have random access. A std::priority_queue is usually backed by a vector.

It just does the "automatic sorting" for you, is all. You wouldn't actually re-sort the whole thing (which would do a lot of pointless comparisons): you'd do a lower/upper bound search for a position to insert your new element. Removal can be similarly specialised, because you know the elements are sorted so can do a binary search.

But the end result is a thing that behaves much like a queue, yes.

I discovered that there was another style.scss file in the storybook directory which, when placed into the root directory of my React application, along with updating the package.json scripts to: