Question

Removing Nodes from a Binary Tree in Java

This section requires you to complete the following method within BinaryTree.java: public void remove(K key) { } The remove method should remove the key from the binary tree and modify the tree accordingly to maintain the Binary Search Tree Principle. If the key does not exist in the binary tree, no nodes should be removed. In case there is a non-null left child, it should take the place of the removed node. However, if the left child is null, then a non-null right child may take its place. If both children are null, then a null node should take the place of the removed node.

Node.Java

public class Node<K extends Comparable<K>, V> {
    private K key;
    private V value;
    private Node<K, V> left, right;

    public Node(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public Node(K key, V value, Node<K, V> left, Node<K, V> right) {
        this.key = key;
        this.value = value;
        this.left = left;
        this.right = right;
    }

    public boolean equals(Node<K, V> other) {
        if (other == null) return false;
        boolean left, right;
        if (this.left == null) {
            left = other.left == null;
        }
        else {
            left = this.left.equals(other.left);
        }
        if (this.right == null) {
            right = other.right == null;
        }
        else {
            right = this.right.equals(other.right);
        }
        return left && right && this.key.equals(other.key) && this.value.equals(other.value);
    }

    public K getKey() {
        return key;
    }

    public V getValue() {
        return value;
    }

    public void setValue(V value) {
        this.value = value;
    }

    public Node<K, V> getLeft() {
        return left;
    }

    public void setLeft(Node<K, V> left) {
        this.left = left;
    }

    public Node<K, V> getRight() {
        return right;
    }

    public void setRight(Node<K, V> right) {
        this.right = right;
    }
}

BinaryTree.Java

public class BinaryTree<K extends Comparable<K>, V> {
    private Node<K, V> root;

    public BinaryTree(Node root) {
        this.root = root;
    }

    public Node<K, V> getRoot() {
        return this.root;
    }

    public void remove(K key) {

//COMPLETE THIS FUNCTION

}

Answer 1

// Node.java

public class Node<K extends Comparable<K>, V> {
  
   private K key;
private V value;
private Node<K, V> left, right;

public Node(K key, V value) {
this.key = key;
this.value = value;
}

public Node(K key, V value, Node<K, V> left, Node<K, V> right) {
this.key = key;
this.value = value;
this.left = left;
this.right = right;
}

   public boolean equals(Node<K, V> other) {
if (other == null) return false;
boolean left, right;
if (this.left == null) {
left = other.left == null;
}
else {
left = this.left.equals(other.left);
}
if (this.right == null) {
right = other.right == null;
}
else {
right = this.right.equals(other.right);
}
return left && right && this.key.equals(other.key) && this.value.equals(other.value);
}

   public K getKey() {
return key;
}

public V getValue() {
return value;
}

public void setValue(V value) {
this.value = value;
}

public Node<K, V> getLeft() {
return left;
}

public void setLeft(Node<K, V> left) {
this.left = left;
}

public Node<K, V> getRight() {
return right;
}

public void setRight(Node<K, V> right) {
this.right = right;
}
}  

//end of Node.java

// BinaryTree.java

public class BinaryTree<K extends Comparable<K>, V> {
private Node<K, V> root;

public BinaryTree(Node root) {
this.root = root;
}

public Node<K, V> getRoot() {
return this.root;
}
public void remove(K key) {
  
       Node<K, V> parent = null; // set parent to null
       Node<K, V> current = root; // set current to root
      
       // loop to get the node with key
       while(current != null)
       {
           // node found, exit the loop
           if(current.getKey().compareTo(key) == 0)
           {
               break;
           }
           else if(current.getKey().compareTo(key) < 0) // if current's key < key, then key if present must be in right subtree since it is a BST
           {
               parent = current;
   current = current.getRight();
           }
           else                // if current's key > key, then key if present must be in left subtree since it is a BST
           {
               parent = current;
   current = current.getLeft();
           }
       }
      
       // key found in tree
       if (current != null)
       {  
           // current is a leaf node i.e no children  
           if(current.getLeft() == null && current.getRight() == null)
           {
               if(parent == null) // if root node, set root to null
               {
                   root = null;
               }
               else // not a root node
               {
                   // if current is left child of parent, set left child of parent to null
                   if(parent.getLeft() == current)
                       parent.setLeft(null);
                   else    // if current is right child of parent, set right child of parent to null
                       parent.setRight(null);
               }
           }
           else if(current.getLeft() == null) // current has no left child, replace the node with right child
           {
               // root node, set root to its right child
               if(parent == null)
               {
                   root = root.getRight();
               }
               else // not a root node
               {
                   // if current is left child of parent, set left child of parent to right child of current
                   if(parent.getLeft() == current)
                       parent.setLeft(current.getRight());
                   else       // if current is right child of parent, set right child of parent to right child of current
                       parent.setRight(current.getRight());
               }
           }
           else
           {
               // has left child
              
               // set rightMost to the left child of current
               Node<K, V> rightMost = current.getLeft();
              
               // loop to get the right most node of the left child of current
               while(rightMost.getRight() != null)
                   rightMost = rightMost.getRight();
              
               // set the right child of right-most node to right child of current
               rightMost.setRight(current.getRight());
               if(parent == null)   // root node, set root to its left child
                   root = root.getLeft();
               else // not a root node
               {
                   // if current is left child of parent, set left child of parent to left child of current
                   if(parent.getLeft() == current)
                       parent.setLeft(current.getLeft());
                   else   // if current is right child of parent, set right child of parent to left child of current  
                       parent.setRight(current.getLeft());
               }          
           }
       }  
   }
}

//end of BinaryTree.java