在二叉树中进行递归操作时，如何删除根节点？

Question

I am writing the delete function of Binary tree. I have divided my cases into 3. One with both child null. One with one child null and one with both childs not null. I am recursively calling the delete operation after case 3. For ex, as you can see I have called delete operation on node 50. This would replace the parent node 50 with 75. Now I have to delete the node 75 from right subtree. So I ran the delete procedure recursively. But I am not getting the desired output because 75 is the root node in right subtree of 50. How do I fix it so that I am able to delete the root

class BST {
    public static void main(String args[]) {
         Tree tr;
         tr = new Tree(100);
         tr.insert(50);
         tr.insert(125);
         tr.insert(150);
         tr.insert(25);
         tr.insert(75);
         tr.insert(20); 
         tr.insert(90);
         tr.delete(50);
    }
}

class Tree {

    public Tree(int n) {
        value = n;
        left = null;
        right = null;
    }

    public void insert(int n) {
        if (value == n)
            return;
        if (value < n)
            if (right == null)
                right = new Tree(n);
            else
                right.insert(n);
        else if (left == null)
            left = new Tree(n);
        else
            left.insert(n);
    }

    public Tree min() {
        if(left == null)
            return this;
        else
            return left.min();
    }

    public Tree max(){
        if(right == null)
            return this;
        else
            return right.max();
    }

    public Tree find(int n)
    {
        if(n == value)
            return this;
        else if(n > value)
            return right.find(n);
        else if(n < value)
            return left.find(n);
        else
            return null;
    }

    public Tree findParent(int n, Tree parent)
    {
        if(n == value)
            return parent;
        else if(n > value)
            return right.findParent(n, this);
        else if(n < value)
            return left.findParent(n, this);
        else
            return null;
    }

    public void case1(int n, Tree tr, Tree parent)
    {
        if(parent.left.value == n)
            parent.left = null;
        else
            parent.right = null;
    }

    public void case2(int n, Tree tr, Tree parent)
    {

        if(parent.left!=null && parent.left.value == n)
            parent.left = parent.left.left;
        else

            parent.right = parent.right.right;

    }

    public void case3(int n, Tree tr, Tree parent)
    {
        int min = tr.right.min().value;
        tr.value = min;
        tr.right.delete(min);
    }


    public void delete(int n) {  

    // fill in the code for delete

        Tree tr = find(n);
        Tree parent = findParent(n, this);

        if(tr == null)
        {
            System.out.println("The tree is not present in Binary Tree");
            return;
        }
        if(tr.left == null && tr.right == null)
        {
            case1(n, tr, parent);

        }
        else if((tr.left == null) || (tr.right == null))
        {
            System.out.print(tr.right.value);
            System.out.print(parent.right.value);
            case2(n, tr, parent);
        }
        else
        {
            case3(n, tr, parent);
        }

    }

    protected int value;
    protected Tree left;
    protected Tree right;
}

Answer 1

Well, you have two options:

First way: you can wrap the tree structure in an object that hides the implementation details of this datastructure. Forward all the relevant modifying calls to the root node, and implement the delete operation to handle the case when the root node should be deleted: in this case you can just replace the reference in the wrapper object.

Second way: Reuse what you have. Don't delete the root node, but overwrite it with the desired new contents. That way you don't have to find and alter the parent of a node, and the problem is solved. This seems much easier though.