redblacktree | Red Black Generic Tree in C

I'll try to answer a more general question here related to code reuse in Rust. If your primary goal is to write the least amount of code as possible, then Rust might not be the tool you want.

That said, there are three major methods you should consider: monomorphization, virtualization, and enumeration.

Per the Rust book:

Monomorphization is the process of turning generic code into specific code by filling in the concrete types that are used when compiled.

You'll be doing a little copy/paste with monomorphization. Then you have virtualization. In Rust this usually means using trait objects.

Finally, we have enumeration. I like enumeration for certain tasks. Using an enum you can specify some top-level type like Tree and then enumerate the kinds of trees you wish to build.

Here's an example:

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!

You don't need to know the type of redBlackTree. You can query for at compile-time with typeof:

There is at least one error that causes undefined behavior:

The RedBlackTree::bstinsert function fails to return a value when it is supposed to return a bool.

To verify this is the error, a line right before the end of the bstinsert function can be placed to verify that this is an error.

This is not a good benchmark. See How do I write a correct micro-benchmark in Java?

To list a few pain points: System.currentTimeMillis doesn't give enough time resolution, your code doesn't do "warm up" iterations to ensure the code is compiled, it does nothing to ensure the compiler doesn't throw the code away because it doesn't have side effects, etc. If you're interested in making better benchmarks, I'd suggest learning to use JMH.

That said, the fact that you are inserting random numbers means you are very likely to avoid the pathological cases that make unbalanced binary search trees perform badly. You are in effect using a "treap" (randomized binary search tree). The overhead is lower than in a red-black tree, so it's not too surprising you may see better performance.

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

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

ok, you asked...

First, that is a great link below there. And will certainly expose
the breadth of your question, strictly keeping to Data Structs.

Abstract_Hierarchies make everything so much easier. At least you are thinking in the right direction. As I see some have mentioned here, at least superficially, the best approach (Language Agnostic) is always the same in OOP.

By the way, Java is an excellent language, to begin practicing OOP principles. In fact, I just deleted that paragraph...

IFace, IFaces, FullInterface. The secret to building any good abstract hierarchy is 'bare bones' implementation. (I won't implement the generics here, but Java has robust support just for this. java.util.collection this is the root of the collections hierarchy).

However, generics are virtually built into the language for you. Everything is an Object in Java. There you go...The most abstract representation of any type you can imagine.

To your specific requirements: in pseudo...or pseudo-pseudo that's all I was ever able to grasp. The pseudo-pseudo(whatever).

INode must have at least:

1. One Private DATA member or Key.

2. Reference to at LEAST, BUT at this point, not more than 2. Child INodes(a minor inconvenience here. java does not give users direct access to memory via pointers, like C/C++) Obviously, this is exactly 2, but 'AT LEAST' is a very important methodology when thinking about progressive implementation. Just the absolute essence, no more.

3. Public accessor and mutator for private DATA.

4. Manager function Declarations.(short list, I don't recall
   whether or not operator overloading is supported in java or not) Can't imagine how the op equals is handled, given the case...hmmm

5. Since an INode is useless(not entireley) apart from its Data
   structure, This is where I would set up private access keys. (Java specific) this also means, in reference to the Manager functions above, INode will not declare a public CTOR. java's version of C++ friend class (ITree) In your case.(look up class access key/Java). This also Exhibits properties of the Singleton Pattern. ---STOP HERE. This, while appearing quite incomplete, is the First stage Implementation of the abstract INode Hierarchy.

This is enough for a Binary Tree Data Structure.
(extend or implement) the INode Interface for a concrete Binary Tree Node class. So far so simple.

Next, we are looking for the design provisions that will satisfy
a BST Node class. It is conceivable, though neither convenient nor
proper, to implement our current INode Interface as a
Binary Search Tree Node class.(no...no...no...modifications!!)it is what
it is...'Closed for Modifcation && Open for Extension;

We will Extend INode from our new Interface...I think I will call it IOrderedNode Interfaces should always have hyper descriptive
naming conventions. (I know, what happened to mine). Actually, it
does reflect the primary difference between a Binary Tree, and a
Binary Search Tree. A Binary Search Tree is simply an Ordered
Binary Tree. There are implications related to this, apparently
trivial, difference. Mainly, all of the practicality of having a
Serial Data Structure. This means, that we should go back to INode
and evaluate (NOT CHANGE!!) the private Data member. --------

Hopefully, we were thoughtful when considering the abstract extensibility
of that Data member. If I remember right, generics in java have been
augmented in versatility...I will leave that to you. To borrow a concept
from C++, I would have used a generic pointer to type of template Arg. Or
better yet a void pointer(can't use the asterisk there 'cause it formats my text) doesn't get more abstract than that! the(void)(star), I mean;

Forget for a moment that you are using java, because all types in java are
integral types, via the hash code inherited from the Object class's
ToString() method. User Defined Types (UDTs) should be well thought out here, because of the disparate implementations across Data Structures that
will implement the series of IFace extensions. (pointers, refs: in java) are always the best initial types at the base levels. They can be
adapted to point to, or hold reference to even the most complex UDT.

Ok, back those Serial attributes we were about to exploit.
Traversals::Pre-Order, In-Order, Post-Order, Breadth-First. Since we are only exploring the INode hierarchy, we should start considering the algorithms that will be implemented in
the associated Data Structures, and try to identify any subordinate
dependencies that will need to appear in our IOrderedNode

The error you are getting is the following:

Compilation error (line xx, col yy): The type 'Program.Interval' cannot be used as type parameter 'T' in the generic type or method 'Program.RedBlackTree'. There is no implicit reference conversion from 'Program.Interval' to 'System.IComparable>'.

You need to take the error apart and think about what it is telling you. In this case you are declaring that IntervalTree inherits from RedBlackTree>. However, you have specified that the generic T type for RedBlackTree must implement IComparable. If you implement IComparable for Interval the error will go away. Interval must implement the interface used to constrict RedBlackTree.