java binaire zoekboom

Is dit huiswerk? Niks mis mee ... we willen alleen maar om mensen te helpen te leren in plaats van hen vertellen de antwoorden.

Als je gewoon stel het kind knooppunt naar null je alle informatie over de kind kinderen verliezen.

Een standaard boom klasse zal weten zijn kinderen, meestal vast te zitten in een array of Collection - in het geval van een binaire boom, heb je maar twee rechtstreekse kinderen, zodat een vast formaat array zal werken. Vanwege dat, ze meestal uit te voeren een soort van "removeMe" methode dat het kind vraagt ​​om aan de slag verwijderd uit die lijst van kinderen houden.

Zoals hierboven vermeld, wordt dit ingewikkeld als het kind dat u het verwijderen van kinderen heeft.

Tim's antwoord lijkt best. Maar ja je zal willen doen één van drie dingen afhankelijk van wat voor soort kind het is uw verwijderen. Als je een kind nul te maken, zal de kinderen van het niet omhoog, omdat je hebt verloren verwijzing naar hen. In plaats daarvan, wil je om te bepalen of de links of rechts kinderen van het kind je het verwijderen moet worden ingesteld op de wijzer wijst naar het kind uw verwijderen. Na het instellen van de vorige knooppunten pointer (links of rechts) om het kind (links of rechts) van het knooppunt uw verwijderen, je gewoon een referentie niet meer naar dat knooppunt, zodat theres geen noodzaak om op null (u kunt' t toegang tot het niet meer. Tenzij u schreef een soort dubbel-gekoppelde BST, in welk geval dat is niet de klassieke BST)

Deze code moet je helpen

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

Je kunt zoiets als dit (pseudo code) doen:

Bij een van de wortel van de boom "root" en het knooppunt te verwijderen of sommige gegevens "x" het volgende doen

 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;

}