java binärer Suchbaum

Ist das Hausaufgaben? Nichts falsch mit dem ... möchten wir nur Menschen und nicht sie die Antworten als sagen lernen helfen.

Wenn Sie nur die untergeordneten Knoten auf null gesetzt Sie irgendwelche Informationen über den Childs Kinder verlieren.

Eine Standard-Baum-Klasse wird ihre Kinder weiß, in der Regel in einem Array oder eine Sammlung stecken - im Fall eines binären Baumes, du hast nur zwei direkte Kinder, so eine feste Größe Array funktioniert. Dieser Grund, implementieren sie in der Regel eine Art von „removeMe“ Methode, die das Kind aus dieser Liste von Kindern zu erhalten entfernt nennt.

Wie oben erwähnt, wird diese kompliziert, wenn das Kind den Sie entfernen, Kinder hat.

Tims Antwort scheint am besten. Aber ja wünschen Sie eine von drei Dinge zu tun, je nachdem, welche Art von Kind es ist, zu entfernen. Wenn Sie ein Kind null machen, werden die Kinder es nicht bewegen, weil man auf sie Bezug verloren haben. Stattdessen sollten Sie, wenn die linke oder rechte Kinder des Kindes sollte Ihre Entfernung zu dem Zeiger, der auf das Kind eingestellt werden, um Ihre Entfernung zu bestimmen. Nachdem Sie die vorherigen Knoten Zeiger (links oder rechts), um das Kind (links oder rechts) des Knotens Ihre entfernen, haben Sie nicht einen Verweis mehr auf diesen Knoten, keine Notwendigkeit, so Theres es auf null gesetzt (Sie können‘gesetzt t Zugriff es nicht mehr. es sei denn, Sie irgendeine Art von doppelt verketteten BST schrieb, in dem Fall, dass nicht die klassische BST ist)

Dieser Code sollte Ihnen helfen

public Node<T> getParentOf(Node<T> child){
    findParentOf(this.root, child);
    return temp;
}

private void findParentOf(Node<T> ROOT, Node<T> child){
    if(ROOT.hasLeft()){
        findParentOf(ROOT.left, child);
    }

    if(ROOT.left == child || root.right == child){
        temp = ROOT;
    }

    if(ROOT.hasRight()){
        findParentOf(ROOT.right, child);
    }
}


private void replaceNode(Node<T> original, Node<T> newNode){
    Node<T> tempParent = getParentOf(original);
    if(original == tempParent.left){
        tempParent.left = newNode;
    }else if(original == tempParent.right){
        tempParent.right = newNode;
    }
}

private void traverseChildrenAndAdd(Node<T> newParent, Node<T> oldParent){
    newParent.insert(oldParent.data);
    if(oldParent.hasLeft()){
        traverseChildrenAndAdd(newParent,oldParent.left);
    }



    if(oldParent.hasRight()){
        traverseChildrenAndAdd(newParent,oldParent.right);
    }
}
private void deleteNode(Node<T> ROOT, Node<T> d){
    if(d.data.compareTo(ROOT.data) < 0){
        deleteNode(ROOT.left, d);
    }else if(d.data.compareTo(ROOT.data) > 0){
        deleteNode(ROOT.right, d);
    }else if(d == this.root){
        if(this.root.hasLeft()){
            traverseChildrenAndAdd(root.left, root.right);
            root = root.left;
        }else if(root.hasRight()){
            root = root.right;
        }else{
            root = null;
        }
    }else{
        if(ROOT.hasLeft()&&ROOT.hasRight()){
            Node<T> successor = getMinNode(ROOT);
            replaceNode(successor, successor.right);
        }else if(ROOT.hasLeft() || ROOT.hasRight()){
            if(ROOT.hasLeft()){
                replaceNode(ROOT, ROOT.left);
            }else{
                replaceNode(ROOT, ROOT.right);
            }
        }else{
            replaceNode(ROOT, null);
        }
    }
}

public void remove(T data){
    deleteNode(this.root, new Node<T>(data));
}

Sie können so etwas wie dieser (Pseudo-Code) tun:

Bei einer der Wurzel des Baumes „root“ und dem Knoten zu löschen oder einige Daten „x“ die folgenden Schritte aus

 if x < root
      recurse to left child
 if x > root
      recurse to right child
 else //node found
      find the min item of the node right child //min item should be left most leaf node node
      replace the value of the node you want to delete with min nodes value
      now delete the min node
 return root;

Code:

delete(Node root, Object x){
    if(root == null){
        return null;
    }

    if(data < root.data){
        root = delete(root.left);
    }else if(root.data < data){
        root = delete(root.right);
    }else{
        if(root.left != null && root.right != null){
            Object tmp = findMin(root.right);
            root.data = tmp;
            root.right = delete(root.right, tmp);
        }else{
            return (root.left != null) ? root.left : root.right;    
        }
    }
return root;

}