Question

(Binary Tree Delete) In this exercise, we discuss deleting items from binary search trees. The deletion algorithm is not as straightforward as the insertion algorithm. There are three cases that are encountered when deleting an itemthe item is contained in a leaf node (i.e., it has no children), the item is contained in a node that has one child or the item is contained in a node that has two children. If the item to be deleted is contained in a leaf node, the node is deleted and the pointer in the parent node is set to null. If the item to be deleted is contained in a node with one child, the pointer in the parent node is set to point to the child node and the node containing the data item is deleted. This causes the child node to take the place of the deleted node in the tree. The last case is the most difficult. When a node with two children is deleted, another node in the tree must take its place. However, the pointer in the parent node cannot be assigned to point to one of the children of the node to be deleted. In most cases, the resulting binary search tree would not adhere to the following characteristic of binary search trees (with no duplicate values): The values in any left subtree are less than the value in the parent node, and the values in any right subtree are greater than the value in the parent node. Which node is used as a replacement node to maintain this characteristic? Either the node containing the largest value in the tree less than the value in the node being deleted, or the node containing the smallest value in the tree greater than the value in the node being deleted. Let us consider the node with the smaller value. In a binary search tree, the largest value less than a parent's value is located in the left subtree of the parent node and is guaranteed to be contained in the rightmost node of the subtree. This node is located by walking down the left subtree to the right until the pointer to the right child of the current node is null. We are now pointing to the replacement node, which is either a leaf node or a node with one child to its left. If the replacement node is a leaf node, the steps to perform the deletion are as follows: 1\. Store the pointer to the node to be deleted in a temporary pointer variable (this pointer is used to delete the dynamically allocated memory 2\. Set the pointer in the parent of the node being deleted to point to the replacement node. [Page \(1042]\) 3\. Set the pointer in the parent of the replacement node to null. 4\. Set the pointer to the right subtree in the replacement node to point to the right subtree of the node to be deleted. 5\. Delete the node to which the temporary pointer variable points. The deletion steps for a replacement node with a left child are similar to those for a replacement node with no children, but the algorithm also must move the child into the replacement node's position in the tree. If the replacement node is a node with a left child, the steps to perform the deletion are as follows: 1\. Store the pointer to the node to be deleted in a temporary pointer variable. 2\. Set the pointer in the parent of the node being deleted to point to the replacement node. 3\. Set the pointer in the parent of the replacement node to point to the left child of the replacement node. 4\. Set the pointer to the right subtree in the replacement node to point to the right subtree of the node to be deleted. 5\. Delete the node to which the temporary pointer variable points. Write member function deleteNode, which takes as its arguments a pointer to the root node of the tree object and the value to be deleted. The function should locate in the tree the node containing the value to be deleted and use the algorithms discussed here to delete the node. The function should print a message that indicates whether the value is deleted. Modify the program of Figs. 21.2021 .22 to use this function. After deleting an item, call the inorder, preorder and postorder TRaversal functions to confirm that the delete operation was performed correctly.

Short answer

Implement deleteNode with cases for leaf, one child, and two children, using in-order successor/predecessor for replacements.

Step-by-step solution

Understand the Problem

The task is to implement a `deleteNode` function for a binary search tree (BST) that removes a node based on specific cases: when the node is a leaf, when it has one child, and when it has two children. We must ensure that the BST properties remain intact after deletion.

Deletion of a Leaf Node

If the node to be deleted is a leaf node (it has no children), simply set the pointer from the parent of this node to `null` and delete the node. This is straightforward since there are no child nodes to reassign.

Deletion of a Node with One Child

For a node with one child, redirect the pointer from the node's parent to the node's child. Remove the node, effectively replacing it with its own child, maintaining the BST structure.

Deletion of a Node with Two Children

In this case, replace the node with either the largest node in its left subtree or the smallest node in its right subtree. These are usually the rightmost node in the left subtree or the leftmost node in the right subtree, respectively.

Locating Replacement Node for Two Children Case

Find the in-order predecessor (largest node in left subtree) or in-order successor (smallest node in right subtree). If the replacement is a leaf, follow the special steps to reassign pointers as needed.

Deletion Process with Replacement Node (Leaf)

If the replacement node is a leaf, adjust pointers to make its parent's child pointer `null`, replace the target node with the replacement node, and delete the target node.

Deletion Process with Replacement Node (One Child)

If the replacement node has one child, point the parent's child to the replacement node's child, then replace the target node with the replacement node, reassigning the child pointers appropriately.

Implement and Test deleteNode Function

Implement the `deleteNode` function in the code, ensuring it handles all three deletion scenarios correctly, and add calls to inorder, preorder, and postorder traversal functions to validate the tree's structure after deletion.

Key concepts

Node Deletion

When dealing with binary search trees (BSTs), the process of node deletion can appear daunting due to the different scenarios that need to be handled. These scenarios are based on the number of children a node has. Each of these cases requires specific steps to ensure that the BST properties, where all nodes in the left subtree are lesser and nodes in the right subtree are greater than the parent node, remain intact.

• Leaf Node Deletion: This is the simplest case, as the node has no children and can simply be removed by setting its parent's reference to it to `null`.


• Node with One Child: When a node has only one child, the child node effectively takes the place of the deleted node. We achieve this by redirecting the parent's pointer to the child of the node being deleted.


• Node with Two Children: This is the most complex case where you have to replace the node with another node in the tree that will maintain the binary search tree property. Typically, this involves finding the in-order predecessor or successor.

Managing these scenarios efficiently is key to maintaining the integrity of the BST upon deletion.

Tree Traversal

Tree traversal refers to the method of visiting all the nodes in a tree data structure, especially binary search trees, in a systematic manner. This is crucial for various operations, especially when verifying the integrity of a tree post-modification, such as after a node deletion.

• Inorder Traversal: This type of traversal visits nodes in ascending order for a binary search tree. It involves traversing the left subtree, visiting the root node, and then traversing the right subtree. This is often used to verify that our BST remains sorted after deletions.


• Preorder Traversal: Preorder involves visiting the root node first, then the left subtree, followed by the right subtree. This can be useful for tree copying or expressing the structure of a tree.


• Postorder Traversal: This traversal method visits the left subtree, the right subtree, and the root node last. It is particularly useful in applications like deleting the tree, as children are processed before the parent.

Using these traversal methods, we can inspect the tree and ensure all nodes align with the desired tree properties after any updates or deletions.

In-Order Predecessor

The in-order predecessor in a binary search tree (BST) is the node that would come right before a given node when the nodes are listed in sorted order. This concept is particularly useful when we are dealing with node deletion where the node to be deleted has two children. To find the in-order predecessor, you need to find the largest node in the left subtree of the node you are looking to delete. Here's how you can determine the in-order predecessor: 1. Go to the left child of the node you need to delete. 2. Continue to traverse to the right child of each subsequent node until there are no more right children. 3. The last node visited will be the in-order predecessor. Locating the in-order predecessor ensures that we can replace a node with one that won't disrupt the ordered structure of the BST. The replacement node provides an effective way to maintain the BST characteristics during deletion, particularly for the cases involving nodes with two children.

Binary Tree Structure

A binary tree is a hierarchical data structure in which each node has at most two children, referred to as the left child and the right child. When this structure is specifically organized as a binary search tree (BST), it enables efficient searching, insertion, and deletion operations.

• Root: The topmost node of the tree.


• Left Child and Right Child: These are the two potential child nodes of any given node, where the left child contains a value less than its parent node, and the right child contains a value greater.


• Leaf Node: A node with no children. Leaf nodes are the simplest cases for deletion.


• Subtrees: Any node and its descendants form a subtree, which is itself a binary tree.

Understanding the binary tree structure is fundamental for implementing algorithms related to BST operations. The simplicity of the binary tree structure provides the foundation that allows operations like searching and deletion to be performed in logarithmic time complexity when the tree is balanced.