BinaryTree | Cross platform Binary Tree C # implementation as NuGet | DevOps library

You were close but your tests are a bit messy.

Here is a patch:

A match expression does not need runtime type information; as a match only accepts a single expression of a single known type, by definition it can leverage compile time information.

See also:

• Is it possible to pattern match in Rust with multiple types?
• How to match on data type in Rust?

At compile time, every match expression will be verified to be exhaustive: all possible shapes of the value are handled.

At run time, the code will determine which specific match arm is executed. You can think of a match as implemented via a fancy if-else chain.

As we humans tend to be not-extremely-precise when communicating, it's highly likely that some resources blur the line between these two aspects.

Enum variants are not standalone types. That is, given an enum Foo, Foo::Bar is not a type — it's a value of type Foo. This is the same as how false is not a type — it's a value of type bool. The same logic applies for i32 (type) and 42 (value).

In most cases, enums are implemented as a sea of bytes that correspond to the values each enum variant might be, with each variant's data layered on top of each other. This is known as a union.

Then a discriminant is added next to this soup of bytes. This is an integer value that specifies which variant the value is. Adding the discriminant makes it into a tagged union.

Matching on an enum is conceptually similar to this pseudo-Rust:

I took the liberty of simplfying your code a bit let me know if you have any questions about how this works.

For me the main issue as I mentioned in the comments was with these line of code

Your traversal methods preorder, postorder and inorder have declarations that you would expect for standalone functions, but they are indented to be part of the class and so they look like methods.

The easiest fix is to move them out of the class block and replace the call in your main program with postorder(pt), and it will work.

If you prefer to have them as methods on your class, so that you can make the call like pt.postorder(), then rename the parameter tree to self (as that is the common practice), make the recursive calls in method-notation, and move the if condition before the recursive calls:

The function isBalanced is correct, but there is an inconsistency in the height function, which makes isBalanced return the wrong result. For instance for this tree, it returns false, but true is expected:

Method 1: Don't update window
You could replace the root.mainloop() with root.update(). This will stop showing any changes to the window. The window will only and always close if the program stops running.

Method 2: using threading
You could useimport threading to run t1.view() in another thread: threading.Thread(target=t1.view).start(). This may result in a Tcl_AsyncDelete error.

node is not going back, you are just saving the result of running sum and passing that to next nodes and once you got child node(leaf node) you are appending sum and return nothing, and this sum is your branch sum

If you want to find out exactly what the allocation difference is, then running the app with https://pypi.org/project/memory-profiler/ should give you the answers you're after. But that only applies to the very theoretical side and the result will be specific to one CPython version and may not hold overall.

In practice the answer is: they're about the same for a few reasons:

• Other code will dominate the performance (just creating new stack frames and would take more space)
• You can't go that deep anyway (default recursion limit is 1000 frames)
• Your data will not be that large (binary trees are usually kept balanced which at 100000 levels it would give you over 10^30102 elements)
• Once you start caring about single bytes and limits like that, CPython stops being the right answer. Cython may be the simplest next step and there you can check the exact heap/stack usage of the resulting C program.