java递归二叉搜索树

我编写了一个布尔插入方法，它将值插入到二元搜索树中，如果值不存在，则插入值，如果存在，则返回true，如果值已经存在，则返回false，因此不插入任何内容。我试图将这种迭代方法转换为完全没有循环的递归，但我在弄清楚如何实现时遇到了困难。感谢您的帮助

public boolean insert(int value) {
    Node travel= root, prev= null, newNode;
    boolean result= true;

    while (travel != null && travel.data != value) {
      prev= travel;
      if (value < travel.data)
        travel= travel.left;
      else travel= travel.right;
    }

    if (travel != null)
      result= false;
    else
      if (root == null)  
        root= new Node(value);
      else
        if (value < prev.data)
          prev.left= new Node(value);
        else prev.right= new Node(value);

    return result;
  }

公共布尔插入（int值）{
节点行程=根，上一个=空，新节点；
布尔结果=真；
while（travel！=null&&travel.data！=value）{
prev=旅行；
if（值<行程数据）
travel=travel.left；
else travel=travel.right；
}
如果（行程！=null）
结果=假；
其他的
if（root==null）
根=新节点（值）；
其他的
if（值<先前数据）
左上=新节点（值）；
else prev.right=新节点（值）；
返回结果；
}

您可以尝试以下方法：

public boolean insert(int value) {
    return insert(value, root);
}

public boolean insert(int value, Node explore) {

    if (explore != null) {
        if (value < explore.data) {
            if (explore.left != null) {
                return insert(value, explore.left);
            } else {
                explore.left = new Node(value);
                return true;
            }
        } else if (value > explore.data) {
            if (explore.right != null) {
                return insert(value, explore.right);
            } else {
                explore.right = new Node(value);
                return true;
            }
        } else {
            // In this case the value already exists
            return false;
        }
    } else {
        explore = new Node(value);
    }
    return true;                
}

公共布尔插入（int值）{
返回insert（值，根）；
}
公共布尔插入（int值，节点探索）{
if（explore！=null）{
如果（值explore.data）{
if（explore.right！=null）{
返回insert（value，explore.right）；
}否则{
explore.right=新节点（值）；
返回true；
}
}否则{
//在这种情况下，该值已经存在
返回false；
}
}否则{
explore=新节点（值）；
}
返回true；
}

您可以尝试以下方法：

public boolean insert(int value) {
    return insert(value, root);
}

public boolean insert(int value, Node explore) {

    if (explore != null) {
        if (value < explore.data) {
            if (explore.left != null) {
                return insert(value, explore.left);
            } else {
                explore.left = new Node(value);
                return true;
            }
        } else if (value > explore.data) {
            if (explore.right != null) {
                return insert(value, explore.right);
            } else {
                explore.right = new Node(value);
                return true;
            }
        } else {
            // In this case the value already exists
            return false;
        }
    } else {
        explore = new Node(value);
    }
    return true;                
}

公共布尔插入（int值）{
返回insert（值，根）；
}
公共布尔插入（int值，节点探索）{
if（explore！=null）{
如果（值explore.data）{
if（explore.right！=null）{
返回insert（value，explore.right）；
}否则{
explore.right=新节点（值）；
返回true；
}
}否则{
//在这种情况下，该值已经存在
返回false；
}
}否则{
explore=新节点（值）；
}
返回true；
}

您可以尝试以下方法：

public boolean insert(int value) {
    return insert(value, root);
}

public boolean insert(int value, Node explore) {

    if (explore != null) {
        if (value < explore.data) {
            if (explore.left != null) {
                return insert(value, explore.left);
            } else {
                explore.left = new Node(value);
                return true;
            }
        } else if (value > explore.data) {
            if (explore.right != null) {
                return insert(value, explore.right);
            } else {
                explore.right = new Node(value);
                return true;
            }
        } else {
            // In this case the value already exists
            return false;
        }
    } else {
        explore = new Node(value);
    }
    return true;                
}

公共布尔插入（int值）{
返回insert（值，根）；
}
公共布尔插入（int值，节点探索）{
if（explore！=null）{
如果（值explore.data）{
if（explore.right！=null）{
返回insert（value，explore.right）；
}否则{
explore.right=新节点（值）；
返回true；
}
}否则{
//在这种情况下，该值已经存在
返回false；
}
}否则{
explore=新节点（值）；
}
返回true；
}

您可以尝试以下方法：

public boolean insert(int value) {
    return insert(value, root);
}

public boolean insert(int value, Node explore) {

    if (explore != null) {
        if (value < explore.data) {
            if (explore.left != null) {
                return insert(value, explore.left);
            } else {
                explore.left = new Node(value);
                return true;
            }
        } else if (value > explore.data) {
            if (explore.right != null) {
                return insert(value, explore.right);
            } else {
                explore.right = new Node(value);
                return true;
            }
        } else {
            // In this case the value already exists
            return false;
        }
    } else {
        explore = new Node(value);
    }
    return true;                
}

公共布尔插入（int值）{
返回insert（值，根）；
}
公共布尔插入（int值，节点探索）{
if（explore！=null）{
如果（值explore.data）{
if（explore.right！=null）{
返回insert（value，explore.right）；
}否则{
explore.right=新节点（值）；
返回true；
}
}否则{
//在这种情况下，该值已经存在
返回false；
}
}否则{
explore=新节点（值）；
}
返回true；
}

公共类二进制搜索树{
私有节点根；
公共布尔插入（int值）{
if（root==null）{
根=新节点（值）；
返回true；
}否则{
返回insert（根，值）；
}
}
专用布尔插入（节点，int值）{
if（值<节点值）{
if（node.left！=null）{
返回insert（node.left，value）；
}否则{
node.left=新节点（值）；
返回true；
}
}else if（值>节点值）{
if（node.right！=null）{
返回insert（node.right，value）；
}否则{
node.right=新节点（值）；
返回true；
}
}否则{
返回false；
}
}
公共无效打印顺序（节点）{
如果（节点！=null）{
printInOrder（node.left）；
System.out.println（“遍历”+节点值）；
printInOrder（node.right）；
}
}
公共静态void main（字符串[]args）{
BinarySearchTree t=新的BinarySearchTree（）；
系统输出打印项次（“插入5:+t插入（5））；
系统输出打印项次（“插入4:+t插入（4））；
系统输出打印项次（“插入7:+t插入（7））；
系统输出打印项次（“插入4:+t插入（4））；
t、 printInOrder（t.root）；
}
}
类节点{
左淋巴结；
节点权；
int值；
公共节点（int值）