java binært søketre

Er dette lekser? Ingenting galt med det ... vi bare liker å hjelpe folk lære heller enn å fortelle dem svarene.

Hvis du bare sette barnet node til null vil du miste noen informasjon om barnets barn.

En standard tre klassen vil kjenne sine barn, som regel fast i en matrise eller Samling - i tilfelle av et binært tre, har du bare fikk to direkte barn, så en fast størrelse utvalg vil fungere. På grunn av at de vanligvis gjennomføre en slags "removeMe" metoden at barnet kaller å bli fjernet fra den listen for barn.

Som nevnt ovenfor, blir dette komplisert hvis barnet du skal fjerne har barn.

Tim svar som virker best. Men ja du vil ønske å gjøre en av tre ting avhengig av hva slags barn det er din fjerne. Hvis du gjør et barn null, vil barn ikke gå opp fordi du har mistet referanse til dem. I stedet vil du ønsker å finne ut om venstre eller høyre barn av barnet ditt å fjerne bør settes til pekeren peker til barnet ditt å fjerne. Etter at du har satt den tidligere noder pekeren (venstre eller høyre) til barnet (venstre eller høyre) av noden din fjerne, vil du ikke ha en referanse lenger til at node, så det er ingen grunn til å sette den til null (du kan' t tilgang til den lenger. med mindre du skrev en slags dobbelt bundet BST, i så fall det er ikke den klassiske BST)

Denne koden skal hjelpe deg

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

Du kan gjøre noe som dette (pseudo-kode):

Gitt en roten av treet "root" og node å slette eller noen data "x" gjør følgende

 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;

kode:

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;

}