Java：二叉搜索树

我决定使用java创建一个二进制搜索树，我想做的是从树中删除Max元素，因此我创建了这部分代码：

public Node<T> removeMax(Node<T> node) {
    if (node == null)
        return null;
    if (node.right == null) {
        Node<T> n = node;
        node = null;
        return n;
    }

    return removeMax(node.right);
}

public Node removeMax（节点）{
if（node==null）
返回null；
if（node.right==null）{
节点n=节点；
node=null；
返回n；
}
返回removeMax（节点右侧）；
}

该方法返回Max元素，但不会将其从树中移除。如您所见，我试图在本部分中删除它：

Node<T> n = node;
node = null;
return n;

Node n=节点；
node=null；
返回n；

但是，当我打印树中的元素时，它也会显示“已删除”的元素。 我做错了什么

---

编辑：我真正想做的是删除Max节点并返回它，这样我现在就可以知道哪个节点被删除了。

现在我注意到你想知道哪个节点被删除了。您所能做的就是删除最大节点并打印树：

 public void deleteMax(Node<T> root) { 
         Node<T> current = root;
         while (current.right.right != null) { 
             current = current.right; 
         } 
         if(current.right.left!=null) {//max has 1 child to left
             current.right=current.right.left;
         }
         else {//max has no child
             current.right=null;
         }
     }

public String printInfix(Node<T> root) {//prints all the data in the tree in infix order

   if(root==null) {
        return "";
   }

 return printAll(root.left+" "+root.data+" "+printAll(root.right);
}

public void deleteMax（节点根）{
节点电流=根；
while（current.right.right！=null）{
current=current.right；
} 
如果（current.right.left！=null）{//max左侧有一个子项
current.right=current.right.left；
}
否则{//max没有孩子
current.right=null；
}
}
公共字符串printInfix（节点根）{//按中缀顺序打印树中的所有数据
if（root==null）{
返回“”；
}
返回printAll（root.left+“”+root.data+“”+printAll（root.right）；
}

现在我注意到您想知道删除了哪个节点。您所能做的就是删除最大节点并打印树：

 public void deleteMax(Node<T> root) { 
         Node<T> current = root;
         while (current.right.right != null) { 
             current = current.right; 
         } 
         if(current.right.left!=null) {//max has 1 child to left
             current.right=current.right.left;
         }
         else {//max has no child
             current.right=null;
         }
     }

public String printInfix(Node<T> root) {//prints all the data in the tree in infix order

   if(root==null) {
        return "";
   }

 return printAll(root.left+" "+root.data+" "+printAll(root.right);
}

public void deleteMax（节点根）{
节点电流=根；
while（current.right.right！=null）{
current=current.right；
} 
如果（current.right.left！=null）{//max左侧有一个子项
current.right=current.right.left；
}
否则{//max没有孩子
current.right=null；
}
}
公共字符串printInfix（节点根）{//按中缀顺序打印树中的所有数据
if（root==null）{
返回“”；
}
返回printAll（root.left+“”+root.data+“”+printAll（root.right）；
}

您想删除二进制搜索树中的节点。因此，基本上您想做的是使其不可访问。为此，您必须使对它的引用为空，即使其父节点指向它的对应指针为空

更改此项：

if (node.right == null) {
    Node<T> n = node;
    node = null;
    return n;
}

if（node.right==null）{
节点n=节点；
node=null；
返回n；
}

为此：

if (node.right.right == null) {
    Node<T> n = node.right;
    node.right = node.right.left;
    return n;
}

if（node.right.right==null）{
Node n=Node.right；
node.right=node.right.left；
返回n；
}

此外，您还需要注意根是树的最大元素时的情况。因此，如果您对BST的根有一些引用，请在上述情况之前添加此情况：

if (node.right == null) {
    Node<T> n = node;
    referenceToTheRootOfBST = node.left;
    return n;
}

if（node.right==null）{
节点n=节点；
referenceotherootofbst=node.left；
返回n；
}

如果您没有对BST根的引用，您可以做的是深度复制根的左节点，然后删除左节点。因此，上述情况更改为：

if (node.right == null) {
    Node<T> n = node;
    //I'll assume you don't call this function if root is the only element.
    //if root is the only element.If that's the case, then just make the 
    //root null before calling this function.
    Node<T> leftNode = node.left;
    node.value = leftNode.value;
    node.left = leftNode.left;
    node.right = leftNode.right;
    return n;
}

if（node.right==null）{
节点n=节点；
//如果root是唯一的元素，我假设您不调用这个函数。
//如果根是唯一的元素。如果是这样，那么只需
//在调用此函数之前，root为null。
Node leftNode=Node.left；
node.value=leftNode.value；
node.left=leftNode.left；
node.right=leftNode.right；
返回n；
}

---

另一种处理root是最大元素的简单方法是在实际调用此函数之前检查它。只需检查root是否有正确的节点，如果没有，则重新分配root引用。

您想删除二元搜索树中的节点。因此，基本上您想做的是使其不可访问。要做的是也就是说，您必须使对它的引用为null，也就是说，使其父对象指向它的对应指针为null

更改此项：

if (node.right == null) {
    Node<T> n = node;
    node = null;
    return n;
}

if（node.right==null）{
节点n=节点；
node=null；
返回n；
}

为此：

if (node.right.right == null) {
    Node<T> n = node.right;
    node.right = node.right.left;
    return n;
}

if（node.right.right==null）{
Node n=Node.right；
node.right=node.right.left；
返回n；
}

此外，您还需要注意根是树的最大元素时的情况。因此，如果您对BST的根有一些引用，请在上述情况之前添加此情况：

if (node.right == null) {
    Node<T> n = node;
    referenceToTheRootOfBST = node.left;
    return n;
}

if（node.right==null）{
节点n=节点；
referenceotherootofbst=node.left；
返回n；
}

如果您没有对BST根的引用，您可以做的是深度复制根的左节点，然后删除左节点。因此，上述情况更改为：

if (node.right == null) {
    Node<T> n = node;
    //I'll assume you don't call this function if root is the only element.
    //if root is the only element.If that's the case, then just make the 
    //root null before calling this function.
    Node<T> leftNode = node.left;
    node.value = leftNode.value;
    node.left = leftNode.left;
    node.right = leftNode.right;
    return n;
}

if（node.right==null）{
节点n=节点；
//如果root是唯一的元素，我假设您不调用这个函数。
//如果根是唯一的元素。如果是这样，那么只需
//在调用此函数之前，root为null。
Node leftNode=Node.left；
node.value=leftNode.value；
node.left=leftNode.left；
node.right=leftNode.right；
返回n；
}

---

处理root是最大元素的情况的另一种简单方法是在实际调用此函数之前检查它。只需检查root是否有正确的节点，如果没有，则重新分配根引用。

这可能是易变性问题吗？如果是，则只需将

return n

更改为

return node

m即可可以修复它。问题是node=null在这里无效，因为

node

是原始树指针的副本。您要做的是：

if（node.right.right==null）{node n=node.right；node.right=null；return n；}

良好的相关阅读：@Omar和node.right.right或node.right是指针的副本，如果node不是。我真的不清楚！@Asker当你调用removeMax（node.righ）时