java arbore binar de căutare

Este aceasta tema? Nimic în neregulă cu asta ... ne place doar pentru a ajuta oamenii să învețe mai degrabă decât să le spun răspunsurile.

Dacă tocmai ați setat nodul copil null veți pierde orice informație cu privire la copii Childs.

O clasă copac standard, va ști copiii săi, de obicei, blocat într-o matrice sau Collection - în cazul unui arbore binar, ai doar doi copii directe, astfel încât o matrice de dimensiuni fixe vor lucra. Din acest motiv, acestea pun în aplicare, de obicei, un fel de metodă „removeMe“, care solicită copilul să se eliminat din această listă de copii.

După cum sa menționat mai sus, acest lucru devine complicat în cazul în care copilul înlăturați are copii.

răspunsul lui Tim pare cel mai bine. Dar da, veți dori să facă una dintre cele trei lucruri, în funcție de ce fel de copil este eliminarea ta. Dacă face un copil nul, copiii lui nu se va deplasa în sus pentru că v-ați pierdut referire la ele. În schimb, veți dori să determine dacă copiii la stânga sau la dreapta ale copilului eliminând ar trebui să fie setat la îndreptat indicatorul copilului eliminând. După ce ați setat anterior, nodurile pointer (stânga sau dreapta) a copilului (stânga sau dreapta) a nodului eliminând, aveți obiceiul o referință mai la acel nod, astfel încât theres nu este nevoie să se stabilească la null (poți“ t mai de acces la aceasta. Doar dacă ai scris un fel de BST dublu legat, caz în care nu este BST clasic)

Acest cod ar trebui să vă ajute

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));
}

Puteți face ceva de genul asta (cod pseudo):

Având în vedere o rădăcină de copac „rădăcină“ și nodul pentru a șterge sau a unor date „x“, efectuați următoarele

 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;

cod:

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;

}