java bináris keresési fa

Ez házi feladat? Nincs ezzel semmi baj ... mi csak szeretnék segíteni az embereknek megtanulni helyett nekik a választ.

Ha csak meg a gyermek csomópont null akkor elveszíti minden olyan információt, ami a gyermek gyermek.

Egy standard fa osztály ismeri annak a gyermekek, általában beragadt vagy array Collection - abban az esetben, egy bináris fa, akkor már csak két közvetlen gyerekek, így egy fix méretű tömbben fog működni. Mert az, hogy általában végre valamiféle „removeMe” módszer, hogy a gyermek kéri, hogy eltávolítja: a lista a gyermekek.

Mint már említettük, ez bonyolulttá válik, ha a gyermek az eltávolítani kívánt gyermek született.

Tim válasz úgy tűnik, a legjobb. De igen, akar csinálni a következő három dolgot attól függően, hogy milyen gyerek ez a eltávolítjuk. Ha egy gyermek null, a gyerekek nem fog mozogni, mert már elvesztette utalás őket. Ehelyett, akkor szeretnénk meghatározni, hogy a bal vagy a jobb gyermek a gyermek az eltávolításával kell állítani a mutatót, a gyermek az eltávolítása. Miután beállította a korábbi csomópontok mutató (balra vagy jobbra), a gyermek (balra vagy jobbra) a csomópont az eltávolítására, akkor szokás hivatkozni többé erre a csomópontra, így ott nem kell úgy beállítani, hogy null (akkor” t hozzáférés többé. Hacsak nem írt valami kétszeresen összekapcsolt BST, ebben az esetben nem ez a klasszikus BST)

Ez a kód segítségével

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

Akkor ilyesmit (pszeudo-kód):

Adott egy a gyökér a fa „root” és a csomópont törölni, vagy valamilyen adat „x” tegye a következőket

 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;

kód:

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;

}