16.3. Recursive Insert Case

So, now let us see how to insert a value, inserting a value in a search tree fairly straight forward, there is only one place because of remember that the tree is listed in order will give us a shorted list. So, now after adding this value it must second give us a shorted list, so it is like saying that they was only one place to insert a value in a shorted list. So, is like insertion in a shorted list, except we have to find that correct place in the tree to hang it.

Inserting a value in a search tree is somewhat similar to placing it in an ordered list. The tree is structured such that every value to the left of any node is smaller, and every value to the right is larger, maintaining an order. This means there is precisely one spot where any new value can fit appropriately. The challenge is to find that correct spot in the tree, much like you would find where a new item fits in a sorted list.

Imagine organizing books on a shelf. If you want to add a new book, you need to find the right spot where it fits between two existing books that are sorted by title. If you carefully look left and right, you will determine exactly where your new book belongs.

So, that when we do this in order traversal, it would be in the correct order when we list it out. And it turns out that basically we have to find out where it should be by searching for it and if it is not present, we add it by this search fields.

When we want to insert a value, we perform an in-order traversal to maintain the sorted nature of the tree. By traversing the tree, we search for the position of the new value. If the value already exists in the tree, we do not add a duplicate; otherwise, we identify the correct position to insert the new node.

Think of searching in a dictionary. When you look for a word, you move from one section to another until you find the exact spot for that word. If you find the word is already listed, you simply skip adding it.

For instance, if you want to insert 21, then we will walked down the tree and we will look for the place where we should find 21. So, it is smaller than 52 we go a left, smaller than 37 we go a left, bigger than 16 we go right and then we find that at 28 those no value of 21, because there is no left, so this since it should be to the left it 28, we add it that.

To insert a specific value, such as 21, we compare it to the node values starting from the root. If it's less than the current node, we move left; if it's greater, we move right, repeating this process until we find an empty spot suitable for inserting 21. In this case, upon reaching 28, we determine there is an empty left child where we can place 21.

Consider a parking lot where cars are arranged in rows. If you need to park a smaller car (21), you drive down the lanes (compare with node values) and identify open spaces (empty child nodes) until you find a suitable spot to park beside a specific car (28).

Now, for instance, if we want to insert 65, then we will go right from 52 and now it is 74 we will look left, where they is nothing to the left. So, we will insert.

When we attempt to insert another value, such as 65, we follow the same process: because 65 is greater than 52, we move right until we reach 74, where we notice there are no left nodes available to accommodate 65. Thus, we insert it there. The same process applies regardless of the position in the tree—values can sometimes be added to nodes that are not leaves.

Imagine adding a piece of furniture to a room. If the room has various sections and you determine the new piece will fit best next to a specific item (like 74), you position it accordingly, instead of just placing it against the wall (leaves only).

Now, it could be that we said try to insert a value that is already there, for instant in my prompt to insert 91. So, we look for 91 and we find it, so we will interpret the insertion of 91 as something which does not disturb it, because we earlier said we do not want to have duplicate values.

If we attempt to insert a value already present in the tree, like 91, we search for it in the tree. Upon finding it, we simply do nothing, as our defined behavior for the tree prohibits duplicates.

Think of a ticketing system at a concert where each attendee has a unique ticket. If someone tries to enter with a ticket that is already validated (duplicate), they are turned away and not allowed another entry.

This is very simple recursive way to do this, so first of all we have a special case which such as that trees empty, then we just create a new node and point to that node.

The recursive insertion method operates by first checking if the tree is empty. If it is, we create a new node containing the value and set it as the root. This approach can be viewed as diving deeper into the tree to find the appropriate insert point, with each recursive call taking on responsibility to manage either left or right children appropriately.

Consider a family tree. If a family is currently empty, creating a new member (node) forms the base of the tree. If others already exist, you would need to navigate through generations to place the new member in the right branch.

If we have to go left and we cannot go left, then we create a new node to our left and we make that node point here by its parent. So, we create a new node here and we say that it is parent is ourselves. So, t dot left dot parent is t; otherwise, we just recursively insert to our left.

When inserting recursively if we determine that we should go left, but the left child is occupied, we proceed with a recursive call to continue searching deeper into the left subtree. If we reach a point where no node exists, we create the new node and attach it as the left child, linking it back to the parent.

Imagine you are building on a treehouse with various branches. If one branch (the left child) is already occupied, you continue exploring downward until you find an empty branch. When you do, you add your new space (node) and connect it to the existing structure.

Likewise, if we do want to go right and there is no right, we insert it to the right and we make it point to ourselves through its parent; otherwise, we recursively insert to the right.

The same logic applies in case we need to insert into the right child. If the right child exists, we recursively navigate right until we find a suitable empty position. Upon discovering a spot, we create a new node and link it back to the parent as its right child.

Continuing with the treehouse analogy, if a branch to the right is blocked, you continue to look further down that branch until a space opens up. This allows you to build another connected area (node) in the direction you planned.

--