binary-search-tree | ☯️ BinarySearchTree & AVLTree | Dataset library

As you see in the book K = {k1; k2;:::;kn} of n distinct keys in sorted order (so that k1 < k2 < k3< k4 < k5)

Because both Fig. 15.9 (a) and Fig. 15.9 (b) are BST so they have the same order if you use preorder traversal: k1=>k2=>k3=>k4=>k5

By swapping the k_3 subtree with leaf d_0, the order will change if you use preorder traversal: k3=>k1=>k2=>k4=>k5

The problem is that when you save your treepath to path you don't delete the contents of treepath.

To do that you need to create a new list for every recursive call:

I think that thinking about the problem in terms of tree insertion is not very helpful, because what you really want to do is to parse a sequence of tokens. So, a plain tree insertion is not very useful. You instead need to construct the tree (expression) in a more specific way.

For example, say I have:

sortedListUtil does two things: it returns the root (1), and it also changes the head (2) so that its invocations are advancing along the list from call to the other recursive call:

helper(i,j) is used to convert array[i:j+1] to a BST.

You could use a case expression:

Change

Let's run through your code as though we were the python interpreter.

Lets start at the first call: binarySearch(start, node)

Here start is the dict defined at the top of your script and node is another dict (which curiously has the same value).

Lets jump inside the call and we find ourselves at: if not root: where root refers to start above and so is truthy so fails this if.

Next we find ourselves at: elif node['key'] < root['key']: which in this case is not True.

Next we pass into the else: and we are at: binarySearch(root['right'], node).

Just before we jump into the first recursive call, lets review what the parameters to the call are: root['right'] from start has the value None and node is still the same dict which we want to insert somewhere. So, onto the recursive call.

Again we find ourselves at: if not root:

However this time root just refers to the first parameter of the first recursive call and we can see from the above review of the parameters that root refers to None.

Now None is considered falsy and so this time the if succeeds and we are on to the next line.

Now we are at root = node.

This is an assignment in python. What this means is that python will use the variable root to stop referring to None and to refer to whatever node currently refers to, which is the dict which was created in the while loop. So root (which is just a parameter, but you can think of as a local variable now) refers to a dict.

Now what happens is that we are at the end of the first recursive call and this function ends. Whenever a function ends, all the local variables are destroyed. That is root and node are destroyed. That is just these variables and not what they refer to.

Now we return to just after the first call site i.e. just after binarySearch(root['right'], node)

We can see here that the parameters: root['right'], node still refer to whatever they were referring to before. This is why your start is unchanged and why your program should deal with left and right now instead of recursing.

Your add function is adding Nodes to the BST according to the name as a key.

That's how you are searching for the Node to delete, when provided a name.

However, when provided co-ordinates, you are searching by using cityCoords as a key. That's not possible. You'll need to search all branches to find the Node to delete.

This is where the issue comes from. The comment is wrong. The code that follows it is wrong as well, although it agrees with the comment.