在二叉樹中進行遞歸操作時，如何刪除根節點？

Question

我正在編寫二叉樹的刪除功能。 我將案例分為3個。一個孩子均為空。 一個帶一個孩子為空的孩子，另一個帶兩個孩子都不為空的孩子。 我將在情況3之后遞歸調用delete操作。例如，如您所見，我在節點50上調用了delete操作。這將用75替換父節點50。現在我必須從右側子樹中刪除節點75。 因此，我以遞歸方式運行刪除過程。 但是我沒有得到所需的輸出，因為75是50的右子樹中的根節點。如何修復它，以便能夠刪除根

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

好吧，您有兩種選擇：

第一種方式：您可以將樹結構包裝在一個對象中，該對象隱藏此數據結構的實現細節。 將所有相關的修改調用轉發到根節點，並執行delete操作以處理應刪除根節點的情況：在這種情況下，您可以只替換包裝對象中的引用。

第二種方式：重用您擁有的東西。 不要刪除根節點，而要用所需的新內容覆蓋它。 這樣，您不必查找和更改節點的父代，問題就解決了。 不過，這似乎容易得多。