Question

我有一个关于如何从节点（root）中删除子节点的问题？由于我无法调用删除，如果我让孩子为空，那孩子的孩子会向上移动吗？就像，我会把它初始化为null吗？或者我会指出孩子的孩子？

Answer 1

在传统的二进制搜索树中，删除节点可能会产生不同的后果，具体取决于节点有多少个子节点：

可以简单地删除没有子节点的节点
可以删除具有一个子节点的节点，并且该节点将被其唯一的子节点替换。无论孩子是左孩子还是右孩，这都适用。
包含两个孩子的节点的规则稍微复杂一些：您必须找到要删除的节点的有序后继或按顺序前导，替换当前节点的值及其前任或前任的值，然后删除后继者或前任（根据这些规则）。

Answer 2

这是家庭作业吗？没有错......我们只是想帮助人们学习而不是告诉他们答案。

如果您只是将子节点设置为null，则会丢失有关子节点子节点的任何信息。

Answer 3

标准树类将知道它的子节点，通常卡在数组或集合中 - 在二叉树的情况下，你只有两个直接子节点，因此固定大小的数组将起作用。因此，他们通常会实现某种“removeMe”方法，孩子会调用该方法从子列表中删除。

如上所述，如果您要移除的孩子有孩子，这会变得复杂。

Answer 4

蒂姆的回答似乎最好。但是，是的，你会想做三件事中的一件，这取决于你移除的是什么样的孩子。如果你让一个孩子为空，那么它的孩子就不会向上移动，因为你已经失去了对它们的引用。相反，您需要确定您的移除子项的左侧或右侧子项是否应设置为指向您删除的子项的指针。将之前的'节点指针（左或右）设置为您删除的节点的子节点（左侧或右侧）之后，您将不再有对该节点的引用，因此无需将其设置为null（您可以'不再访问它。除非你写了某种双重链接的BST，在这种情况下，这不是经典的BST）

Answer 5

此代码可以帮助您

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

Answer 6

你可以这样做（伪代码）：

鉴于树的根源＆＃34; root＆＃34;以及要删除的节点或某些数据＆＃34; x＆＃34;执行以下操作

 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;

代码：

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;

}

java二进制搜索树

6 个答案: