rbtree | rbtree implementation adapted from linux kernel

There are several things that go wrong here:

• You only measure one insertion or erasure. You should try to measure how long it takes to perform a hundred thousand entries and take the average.
• You don't perform any warm-up. The set operation might operate with a cold CPU cache, the next memory allocation might not be satisfiable without the standard library needing to request a block of memory from the operating system, and so on. Try running a loop that does an operation on a hundred thousand iterations before you start the actual measurement.
• Your process might not run uninterrupted. There are many processes running on your computer, it could be that the operating system decides to pause your process for a while, giving another process a chance to run. If this happens between recording the start and stop, it will look like your operation took a long time.
• Most CPUs nowadays are changing the frequency at which they run all the time, in order to be power efficient and to stay cool. It could be that in some runs, the CPU frequency was different than in others. Having a warm-up phase and averaging many operations will help mitigate this effect.

I suggest you start using an existing benchmarking library to perform this kind of performance tests, like for example Google Benchmark. Often these libraries already solve some of these issues for you.

I think your problem is that removeBST(root, node) always returns root (possibly with different children). If you do a rotation, you should return the new root of the subtree.

Where does it cause problems in your example?

You call root.left = this.removeBST(root.left, node); with root.value = 42, root.left.value = 10. You do what you need to do in the left subtree, but then assign the node with value 10 as the left child of 42.

You also call root.right = this.removeBST(root.right, node); when root.value is 10 and root.right.value is 29. You do the rotation correctly (if you look at this.root just after the rotation, it looks good), but then you return the node with value 29 and assign it to root.right!

The syntax in

For the padding issue:

Make sure the size of your free list nodes is a power of 2 -- either 16 or 32 bytes -- and make sure the addresses of your free list nodes are all aligned at node_size * x - sizeof(Header) bytes.

Now all of your allocations will automatically be aligned at multiples of the node size, with no padding required.

Allocations requiring larger alignments will be rare, so it might be reasonable just to find the left-most block of appropriate size, and walk forward in the tree until you find a block that works.

If you need to optimize large-alignment allocations, though, then you can sort the blocks first by size, and then break ties by sorting on the number of zeros at the right of each nodes's allocation address (node address + sizeof(Header)).

Then, a single search in the tree will either find an exactly-fitting block that works, or a larger block. There is a good chance you'll be able to split the larger block in a way that satisfies the alignment requirement, but if not, then you can again skip ahead in the tree to find a block of that size that works, or an even larger block, etc.

The resulting search is faster, but still not guaranteed O(log N). To fix that, you can just give up after a limited number of skips forward, and revert to finding a block of requested_size + requested_alignment. If you find one of those, then it is guaranteed that you'll be able to split it up to satisfy your alignment constraint.

You should not use a pointer to implement inheritance. Use a Node field instead of a pointer:

For the error you're seeing, @Shon is correct. You have this expression:

Can I do that with a balanced binary search tree (BST) like a Red-Black Tree?

Yes.

Which Python3 module has a data structure with those properties?

The Python built-in data structure set has O(log n) insert, delete and lookup. More precisely, a tighter bound for all these operations is (amortised) O(1).

However, these sets are not sorted. These are provided by sortedcontainers.

sortedcontainers as far as I've seen doesn't have these trees for usage (they are writen in C and are base for SortedList, SortedDict and SortedSet).

I'm not exactly sure about the implementation details of the library, but SortedSet (or more generally SortedDict) are what you want (O(log n) insert, O(log n) delete, O(1) lookup) if you require sorted sets. Otherwise, use the built-in set.

One issue is that you're storing pointers to local variables within the queue:

The benchmark was wrongly implemented, a correct version: