rbtree | RB-Trees for Ruby - originally by OZAWA Takuma

Have a balanced binary tree of some sort of endpoints along with whether they are open or closed.

To insert [a, b] your logic will look like this:

You have to remember that templated types are completely independant.

You have listed the properties of Red-Black trees correctly. Of the four trees only C is not a valid red-black tree:

A.

This is a valid tree. Wikipedia confirms:

every perfect binary tree that consists only of black nodes is a red–black tree.

B.

I think this is valid, but I am not sure since there two adjacent red nodes?

It is valid. There is no problem with red nodes being siblings. They just should not be in a parent-child relationship.

C.

I think this is valid, but I am not sure since there two adjacent red nodes?

It is not valid. Not because of the adjacent red nodes, but because of property 5. The node with label 12 has paths to its leaves with varying number of black nodes. Same for the node 25.

As a general rule, a red node can never have exactly one NIL-leaf as child. Its children should either both be NIL-leaves, or both be (black) internal nodes. This follows from the properties.

D.

I think this is not valid since it violate Property 4?

Property 4 is not violated: the children of the red nodes are NIL leaves (not visualised here), which are black. The fact that these red nodes have black NIL leaves as siblings is irrelevant: there are no rules that concern siblings. So this is valid.

For an example that combines characteristics of tree C and D, see this valid tree depicted in the Wikipedia article, which also depicts the NIL leaves:

I mostly agree with your algorithm. But I disagree with attempting to fix a node when only 1-child. Once you found the node to delete - count its children There are 3 situations where a deleting node is easy, cheap to do. Those are

1. 0-children and the node is red => just delete it
2. 0-children and the node is the root node => just delete it
3. 1-child, all situations. The reality is the node to delete is black and the child red. The other 3 possibilities are all invalid Red-Black trees and so don't occur. The solution is delete the node, replace with the child, and make the child black. No other further fixup's are required.

For 2-children, you need to find either successor (right child then left as far as you can go) or predecessor (left child then right far as you can go). This node will always be a 0 or 1 child case, it cannot be 2. I would test to see if the successor/predecessor is a "cheap to delete" node and if not, choose the predecessor/successor. Your aiming to get a cheap delete. You then need to swap the node to delete with the successor/predecessor BUT THE ORIGINAL COLOURS ARE PRESERVED. Having swapped the nodes (and I mean all the pointer links), your problem then reduces to deleting a node that has 0 to 1 child which may be easy.

So what is left?

That is deleting a 0-children node, a leaf node, the colour is black and it is not the root node. This is the case that requires fixups, no other case requires fixups.

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: