Java 泛型类型二叉搜索树的remove方法导致堆栈溢出问题

我遇到了这个关于实现泛型类型二叉搜索树的remove方法的实验室问题

我已经实现了一个泛型类型的二进制搜索树

我已经学习了二叉搜索树移除算法，并且尝试处理父节点有“0子节点”、“1子节点”或“2子节点”的3种情况

我实现了删除节点的代码，但一直导致堆栈溢出问题，我无法找到代码中的错误之处

任何帮助都将不胜感激

public class BinarySearchTree<T extends Comparable<T>> {

    private Node<T> _root; //Root node

    public class Node<T extends Comparable<T>> {
        public T get_value() {return _value;}

        public void set_value(T _value) {this._value = _value;}

        public Node<T> get_left() {return _left;}

        public void set_left(Node<T> _left) {this._left = _left;}

        public Node<T> get_right() {return _right;}

        public void set_right(Node<T> _right) {this._right = _right;}

        public Node<T> get_parent() {return _parent;}

        public void set_parent(Node<T> _parent) {this._parent = _parent;}

        T _value;           // Node value
        Node<T> _left;      // Left child

        Node<T> _right;     // Right child
        Node<T> _parent;    // Parent node

        public Node(T key, Node<T> parent, Node<T> left, Node<T> right) {
            _value = key;
            _left = left;
            _right = right;
            _parent = parent;
        }
    }
    // Remove a node from the BST
    private Node<T> remove(BinarySearchTree<T> bst, Node<T> z) {
        Node<T> delNode = null;
        if(bst._root == null){
            delNode = null;
        }
        else{
            Node<T> current = bst._root;
            // find the position to delete
            while(current!=null){
                int compare = z.get_value().compareTo(current.get_value());
                if(compare < 0){
                    current = current.get_left();
                }
                if(compare > 0){
                    current = current.get_right();
                }
                else{
                  // if node has two child,replace it with right minimum value
                    if (current._left!=null && current._right!=null){
                        delNode = current;
                        Node<T> successor = minimumKey(current.get_right());
                        current.set_value(successor.get_value());
                        remove(successor._value);
                    }
                    if (current._left!=null){
                        delNode = current;
                        remove(current._value);
                        current._left.set_parent(current._parent);
                    }
                    if (current._right!=null){
                        delNode = current;
                        remove(current._value);
                        current._right.set_parent(current._parent);
                    }
                    else{
                        delNode = current;
                        remove(current._value);
                    }
                }
            }

        }


        return delNode;

    }
    // remove a node value
    public void remove(T key) {
        Node<T> z, node;
        if ((z = find(_root, key)) != null)
            if ( (node = remove(this, z)) != null)
                node = null;
    }
    public Node<T> minimumKey(Node<T> current) {
        while (current._left != null) {
            current = current._left;
        }
        return current;
    }
}

公共类二进制搜索树{
私有节点_root；//根节点
公共类节点{
public T get_value（）{return_value；}
public void set_value（T_value）{this._value=_value；}
公共节点get_left（）{return_left；}
公共无效集_left（节点_left）{this._left=_left；}
公共节点get_right（）{return_right；}
public void set_right（Node_right）{this._right=_right；}
公共节点get_parent（）{return_parent；}
public void set_parent（节点_parent）{this._parent=_parent；}
T _value；//节点值
节点_left；//左子节点
节点_right；//右子节点
节点_parent；//父节点
公共节点（T键、节点父节点、左节点、右节点）{
_值=键；
_左=左；
_右=右；
_父母=父母；
}
}
//从BST中删除节点
删除专用节点（BinarySearchTree bst，节点z）{
Node delNode=null；
if（bst.\u root==null）{
delNode=null；
}
否则{
节点电流=bst.\u根；
//找到要删除的位置
while（当前！=null）{
int compare=z.get_value（）.compareTo（current.get_value（））；
如果（比较<0）{
current=current.get_left（）；
}
如果（比较>0）{
current=current.get_right（）；
}
否则{
//若节点有两个子节点，则将其替换为右最小值
if（当前。_左！=null和当前。_右！=null）{
delNode=当前；
节点后继者=minimumKey（current.get_right（））；
当前.set_值（后续.get_值（））；
删除（后继值）；
}
if（当前值。_左！=null）{
delNode=当前；
移除（当前值）；
当前。左。设置父项（当前。父项）；
}
if（当前值）.\u right！=null）{
delNode=当前；
移除（当前值）；
当前。右。设置父项（当前。父项）；
}
否则{
delNode=当前；
移除（当前值）；
}
}
}
}
返回节点；
}
//删除节点值
公共无效删除（T键）{
节点z，节点；
如果（（z=find（_root，key））！=null）
如果（（node=remove（this，z））！=null）
node=null；
}
公共节点最小密钥（节点当前）{
while（当前。_左！=null）{
电流=电流。_左；
}
回流；
}
}

您的条件有问题。它们应该是：

        if(compare < 0) {
            current = current.get_left();
        } else if(compare > 0) {
            current = current.get_right();
        } else {
            ...

if（比较<0）{
current=current.get_left（）；
}否则如果（比较>0）{
current=current.get_right（）；
}否则{
...

现在，如果

compare<0

为

true

，则执行

current=current.get_left（）；

和

else

子句

---

我不确定这是你的

remove

方法的唯一问题。

谢谢你指出我的else if条件！我只是意识到我可能总是执行

get\u left（）

和

else

条件中的任何内容，但是，它仍然会导致溢出问题，我正在考虑我的while循环是否有问题