java中递归方法的突破

设置“标志”时如何保存它。例如，当我在街区时

if (hashFunction(value) == hashFunction(node.value))
{

    flag = true;
    return flag; 

}

in debug flag=true，但下一步和指针位于

if (hashFunction(value) < hashFunction(node.value))
    {
        if (node.left != null)
        {

            findPrivate(value, node.left);------THERE

        } else
        {
            flag = false;
            return flag;
        }
    }

if（hashFunction（value）

结果，我的方法返回false。如何修复它？对不起我的英语。完整代码如下

    private boolean findPrivate(T value, Node node)
{

    if (node == null)
    {
        flag = false;
        return flag;

    }
    if (hashFunction(value) == hashFunction(node.value))
    {

        flag = true;
        return flag; 

    }

    if (hashFunction(value) > hashFunction(node.value))
    {
        if (node.rigth != null)
        {
            findPrivate(value, node.rigth);
        } else
        {

            flag = false;
            System.out.println("value= " + value + " " + flag);
            return flag;
        }
    }

    if (hashFunction(value) < hashFunction(node.value))
    {
        if (node.left != null)
        {

            findPrivate(value, node.left);

        } else
        {
            flag = false;
            return flag;
        }
    }
    return flag;
}

私有布尔findPrivate（T值，节点）
{
if（node==null）
{
flag=false；
返回标志；
}
if（hashFunction（value）=hashFunction（node.value））
{
flag=true；
返回标志；
}
if（hashFunction（value）>hashFunction（node.value））
{
如果（node.rigth！=null）
{
findPrivate（值，node.rigth）；
}否则
{
flag=false；
System.out.println（“value=“+value+”“+flag”）；
返回标志；
}
}
if（hashFunction（value）

问题在于，当您递归时，忽略了返回值：

findPrivate(value, node.left);

我还没有详细介绍，但您可以将每次出现的情况更改为：

return findPrivate(value, node.left);

我还建议完全删除

标志

变量-不清楚它在哪里声明，但看起来可能不应该使用它；相反，只需直接返回值。例如：

if (node.left != null)
{
    return findPrivate(value, node.left);
} else
{
    return false;
}

。。。然后可以轻松地将其重构为：

return node.left != null ? findPrivate(value, node.left) : false;

事实上，由于您已经返回了

false

，如果

node

为null，您可以使用：

return findPrivate(value, node.left);

---

那样的话。我怀疑您可以很简单地按照这些思路重构代码…

问题是，当您递归时，您忽略了返回值：

findPrivate(value, node.left);

我还没有详细介绍，但您可以将每次出现的情况更改为：

return findPrivate(value, node.left);

我还建议完全删除

标志

变量-不清楚它在哪里声明，但看起来可能不应该使用它；相反，只需直接返回值。例如：

if (node.left != null)
{
    return findPrivate(value, node.left);
} else
{
    return false;
}

。。。然后可以轻松地将其重构为：

return node.left != null ? findPrivate(value, node.left) : false;

事实上，由于您已经返回了

false

，如果

node

为null，您可以使用：

return findPrivate(value, node.left);

那样的话。我怀疑您可以很简单地按照这些思路重构代码…

您需要从递归调用返回值：

private static final class Node<T> {

    protected T value;
    protected Node<T> right;
    protected Node<T> left;

    private boolean findPrivate(T value, Node<T> node) {
        if (node == null) {
            return false;
        }
        if (hashFunction(value) == hashFunction(node.value)) {
            return true;
        }
        if (hashFunction(value) > hashFunction(node.value)) {
            if (node.right != null) {
                return findPrivate(value, node.right);
            } else {
                return false;
            }
        }
        if (hashFunction(value) < hashFunction(node.value)) {
            if (node.left != null) {
                return findPrivate(value, node.left);
            } else {
                return false;
            }
        }
        throw new UnsupportedOperationException("cannot compare hashCodes");
    }

    private int hashFunction(T value) {
        //stuff
    }
}

私有静态最终类节点{
保护T值；
受保护的节点权限；
左保护节点；
私有布尔findPrivate（T值，节点）{
if（node==null）{
返回false；
}
if（hashFunction（value）=hashFunction（node.value））{
返回true；
}
if（hashFunction（value）>hashFunction（node.value））{
if（node.right！=null）{
返回findPrivate（值，node.right）；
}否则{
返回false；
}
}
if（hashFunction（value）

您不需要实际保存

标志

，只需要

返回值。
您需要从递归调用返回值：

private static final class Node<T> {

    protected T value;
    protected Node<T> right;
    protected Node<T> left;

    private boolean findPrivate(T value, Node<T> node) {
        if (node == null) {
            return false;
        }
        if (hashFunction(value) == hashFunction(node.value)) {
            return true;
        }
        if (hashFunction(value) > hashFunction(node.value)) {
            if (node.right != null) {
                return findPrivate(value, node.right);
            } else {
                return false;
            }
        }
        if (hashFunction(value) < hashFunction(node.value)) {
            if (node.left != null) {
                return findPrivate(value, node.left);
            } else {
                return false;
            }
        }
        throw new UnsupportedOperationException("cannot compare hashCodes");
    }

    private int hashFunction(T value) {
        //stuff
    }
}

私有静态最终类节点{
保护T值；
受保护的节点权限；
左保护节点；
私有布尔findPrivate（T值，节点）{
if（node==null）{
返回false；
}
if（hashFunction（value）=hashFunction（node.value））{
返回true；
}
if（hashFunction（value）>hashFunction（node.value））{
if（node.right！=null）{
返回findPrivate（值，node.right）；
}否则{
返回false；
}
}
if（hashFunction（value）

您不需要实际保存
标志
，只需要
返回
值。
没有递归就不能这样做。没有递归就不能这样做。