key-value-store | value store API with implementations for different backends | REST library

Here is my suggested approach.

Every node should be a 32 entry array. If the first entry is null or an array, it is a 32-way split of the whole search space. Otherwise it is descending list of the entries in this block. Fill in the non-entries with -1.

This means that in no more than 5 lookups we get to the block that either has or doesn't have our value. We then do a linear scan. A binary search of a sorted list naively seems like it would be more efficient, but in fact it involves a series of hard to predict branches which CPUs hate. In a low level language (which I hope yours is), it is faster to avoid the pipeline stall and do a linear search.

Here is an implementation in JavaScript.

You don't need to use .get:

Choosing hash over string has many benefits and some drawbacks depending on the use cases. If you are going to choose hash, it is better to design your json object as hash fields & values such as;

Sure, you do it like this:

Don't write a template metaprogram, where it is not necessary. Try this simple solution (CTMap stands for compile time map):

To your title question: Yes, they do.

To your hypothetical sorted set implementation question: No, you can't.

One, you're mistaken on the implementation of deque; it's not a plain "item per node" linked list, it's a block of items per node (64 on the CPython reference interpreter, though that's an implementation detail). And aside from the head and tail blocks, internal blocks are never left empty, so insertion midway through the deque isn't particularly cheap, it still has to move a bunch of stuff around. It's not O(n) like a mid-list insertion, as it takes advantage of some efficiencies in rotation to rotate, append to one side or the other, then rotate back, but it's a far cry from insertion at a known point in a linked list, remaining O(n) (though with large constant divisors thanks to shuffling whole blocks being cheaper than moving each of the individual items).

Two, each lookup in a deque is O(n), not O(1) like a list; it has a constant divisor of 64 as stated previously, and it's drops to O(1) near either end of the deque, but it's still O(n) in general, which scales poorly for large deques. bisect searches are O(log n) under the assumption that indexing the sequence is O(1); for a deque, they'd be O(n log n), as they'd perform log n O(n) indexing operations. This matches your results from testing; bisect+deque is significantly worse.

Java's TreeMap isn't implemented in terms of binary search and a linked list in any event; linked lists are no good for this, since ultimately a full binary search must traverse back and forth enough that it does O(n) total work, even if it only has to compare against O(log n) elements. A tree map needs a tree structure of some sort, you can't just fake it with a linked list and a good algorithm.

Built-in alternatives include:

1. insort of a normal list: Sure it's O(n) overall, but the expensive part (finding where to insert) is O(log n), and it's only the "make room" step that's O(n), and it's a really cheap O(n) (basically a memcpy). Not acceptable for truly huge lists, but you'd be surprised how large a list you'd need before the overhead was noticeable against Python's slowness.
2. Delayed, buffered sorting: If lookups are infrequent, but insertions are common, defer the sort until needed to minimize the number of sorting operations; just append the new elements to the end without sorting and set a "needs sorting" flag, and re-sort before a lookup when the flag is set. The TimSort algorithm does very well when the input is already mostly sorted (much closer to O(n) than a general purpose sort without optimizations for partially sorted typically can do), so it may be fine.
3. If you only need the smallest element at any given time, the heapq module can do that with true O(log n) insertions and removals, and gets the minimum with O(1) (it's always index 0).
4. Use a sqlite3 database (possible via shelve), indexed as appropriate; sqlite3 indices default to using a B-tree, meaning queries ordered using the index key(s) get the results back in sorted order "for free".

Otherwise, you'll have to install a third-party module that provides a proper sorted set-like type.

I have searched both in the past and in the present for an open-source solution to this problem but I have not found one that satisfies my appetite. This time I decided to start building my own and discuss openly its implementation that also covers the null case, i.e. missing data scenario.

Do notice that secondary index is very close to adjacency list representation, a core element in my TRIADB project and that is the main reason behind searching for a solution.

Let's start with one line code using numpy