Question

我正在阅读java中的递归方法...我没有解析递归方法的基本条件......这里有两个例子

public int weight() {
return weight(root);
}
/ * Returns the weight of the tree where n is the root. * /
private int weight(Node n) {
if (n == null) {
return 0;
} else if (n.left == null) { // då är n.right också null
return n.data;
} else {
return weight(n.left) + weight(n.right);
}
}

public boolean isMobile() {
if (root == null) {
return true;
} else {
return isMobile(root);
}
}
/ * Returns true if the tree where n is the root of a mobile. * /
private boolean isMobile(Node n) {
if (n.left == null) { // då är n.right också null
return true;
} else {
return isMobile(n.left) && isMobile(n.right) &&
weight(n.left) == weight(n.right);
}
}

我的疑惑：在weight（）方法中我们为什么不这样做：

public int weight() {
if (root == null) {
    return 0; 
} else {
    return weight(root);
    }
}

正如您所看到的，isMobile（）方法中的基本条件直接位于其下，但weight（）方法中的基本条件位于私有方法下。什么时候可以直接在它下面或在一个单独的私有方法中写入递归的基本条件？

由于

编辑：

public int weight() {
    if (root == null) {
        return 0; 
    } else {
        return weight(root);
        }
    }

private int weight(Node n) {
    if (n == null) {
    return 0;
    } else if (n.left == null) { // då är n.right också null
    return n.data;
    } else {
    return weight(n.left) + weight(n.right);
    }
    }

Answer 1

在weight()方法中我们为什么不这样做：[...]

简单的答案是因为方法的无参数weight()重载不是递归的，即使它依赖于以Node为参数的递归实现。基本条件必须在递归方法本身，因为这是决定停止调用自身的地方。

尽管同名的重载，你的两个权重方法一起工作：

public int nonRecursiveWeight() {
    return recursiveWeight(root);
}
private int recursiveWeight(Node n) {
    ...
}

nonRecursiveWeight提供了一个很好的公众＆＃34;前线＆＃34;对于递归实现recursiveWeight，将节点隐藏在API用户中。

isMobile对方法遵循相同的安排：你有一个递归实现，一个非递归＆＃34;前面＆＃34;共享相同的名称。

Answer 2

你的重写可能意味着if (root == null)。

你仍然需要检查weight(Node)，因为它是递归的 - 为什么要两次？

Answer 3

基本条件必须在递归方法中。方法weight()不是递归的，因为它不会调用自身。它调用一个递归方法weight(Node n)，它必须具有基本条件。

if (n == null) { return 0; }

isMobile()和isMobile(Node n)中的意图略有不同。作者可能想直接在root == null方法中检查isMobile()，以避免在递归方法中进行双重检查，但可以像下面这样重写：

public boolean isMobile() {
  return isMobile(root);
}

private boolean isMobile(Node n) {
  if ( n == null || n.left == null ) return true;
  return isMobile(n.left) && isMobile(n.right) && weight(n.left) == weight(n.right);
}

再次isMobile(Node n)是递归的，isMobile()不是。 isMobile方法现在看起来与weight方法相同。通常，规则是递归方法是调用自身的方法，它们必须具有终止递归的基本条件。

另请注意，如果您之前有回复，则无需撰写else。例如：

boolean someMethod() {
  if ( something ) {
    return true;
  } else {
    return false;
  }
}

可以改写为：

boolean someMethod() {
  if ( something ) {
    // ...
    return true;
  }
  // if something was true then the next piece of code will never get executed
  // if was not true then the next piece of code will always execute

  // ...
  return false;
}

在递归方法

3 个答案: