Question

Hello. I have written the following function to remove a value from a Binary Search Tree using resources my professors gave and stuff I found online. The problem is I don't know how it works and I need to know how it works to finish the rest of the project.

public boolean remove(T value){
    if(value == null) return false;
    class RemoveBSTObj{
        private boolean found = false;
        private Node removeBST(Node root, T value){
            if(root == null) return root; //IF there is nothing to delete just return the root
             //Recurse down the tree to find the value
             if(value.compareTo(root.data) < 0) { //if the value passed is greater than current node, recurse to the right
                 if (root.left != null)
                     root.left = removeBST(root.left, value);
             }
             else if(value.compareTo(root.data) > 0) { //if the value passed is less than current node, recurse to the left
                 if (root.right != null)
                     root.right = removeBST(root.right, value);
             }
             else{ //Now we have found the node to be deleted
                 found = true; 
                 //If the node we have found is has only one child, we can just return that child
                 if(root.right == null) return root.left;
                 else if(root.left == null) return root.right;
                 //IF the node we ave found has two children, we have to get the inOrder predesccor, which is the maximum the left subtree, and delete it
                 root.data = findPredecessor(root);
                 root.left = removeBST(root.left, root.data);
             }
             return root;
         }
     }
     RemoveBSTObj removeBSTObj = new RemoveBSTObj();
    Node holder = removeBSTObj.removeBST(root, value);
    if(!removeBSTObj.found || holder == null) return false;
    root = holder;
    size--;
   return true;
}

//findPredecessor is used in the remove() function

public static T findPredecessor(Node t){
    if(t == null || t.left == null) return null; //return null if t is null or t(the root) has no left children, meaning t is the smallest
     return findMax(t.left); //we are looking for the largest value in the left subtree, which is just the maximum value of the left subtree
 }

//findMax is used in the findPredecessor() function

public static  T findMax(Node t){
    if(t == null) return null;
    if(t.right == null) return t.data; //if we find the maximum, return the data
    return findMax(t.right); //if no max found, continue recursing down the right
}

Answer 1

In a binary tree, you can have 3 cases when you find a particular node X, which need to be deleted.
1) The treenode has no children: In this case, you just remove the reference of X from X's parent and you are done, because there are no children of X, you don't need to worry about them.

2) The treenode has 1 child, either left or right but not both: In this case, You need to delete X, and X has a child Y. So You go to X's parent P, and instead of X getting attached to P, You attach Y to P on the same direction (If x was left child of P, then Y also becomes left child of P, and similar for right child).

3) The third and last case is when the node X (to be deleted) has both left and right children present.. in this case, We can not directly attach child Y1 and Y2 to parent P. We need to find the node which is just smaller than node X, which is known as predecessor. As in BST, root has more value than left subtree, and less value than right subtree.. So to find the predecessor of X, We go to left subtree of X and then keep on moving right till we can.. that way we reach to the predecessor of X.


Like in above image, if you need to delete 20, which has 2 child (8 and 22), then we need to find predecessor of 20. So we go to left subtree of 20, i.e. node 8. The from there, keep on moving right till we can.. so 8 -> 12 -> 14.. It means 14 is the predecessor of 20.

Next thing after finding predecessor is to copy the node value from predecessor to X. So we copy value 14 to node which contains 20 currently.. and then our target to delete will be predecessor node.. as predecessor node has no right child, we can call our above described algorithm which will help in deleting one child case.

I have tried to be very clear and thus used images.. let me know if something is not clear. Thanks!

20 8 4 12 10 14