Java递归编译错误答案

【问题标题】：Java Recursion compilation errorJava递归编译错误
【发布时间】：2014-04-28 22:19:40
【问题描述】：

我是计算机科学专业的新生，目前我们学习 Java 递归。不幸的是，学院只解释了关于这个主题的以下内容：

递归是什么意思。
使用递归算法时有两种情况：基本情况和递归情况及其用途。
使用递归实现阶乘和斐波那契的示例。

现在我得到了以下练习：

如果两个整数的最大公约数（又名 GTC）ONLY 1”，则它们将被称为“陌生人”。例如，数字 8 和 9 是“陌生人”，因为它们的 GTC 为 1 . 但是，8和9并不是“陌生人”，因为他们的GTC是2。

请实现一个递归方法，它接收一个整数数组，如果这个数组中的每一对数字都是陌生人，则返回“true”，否则返回“false”。

方法签名必须如下：
public boolean checkGCD(int[] values)
例如：

{3, 5, 7, 11} -> 方法将返回 true。
{4, 7, 8, 9} -> 方法将返回 false，因为 4 和 8 并不陌生。

如需帮助，您可以使用以下方法查找 GTC（欧几里得算法）：
private static int gcd(int n, int m){
    if (m==0) 
    return n;

    return gcd(m,n % m);
}
另外，方法checkGCD(int[] values)应该重载...

不能使用循环！

使用嵌套循环可以很容易地完成上述操作，但我必须使用递归！

我知道我需要使用一个重载方法，它可以获取the array、lo index 和hi index。

这就是我想到的：

@@@@@@

基本情况：如果数组中至少有一对不陌生的数字，则方法返回false（无需继续比较...）。

@@@@@@

比较将通过以下方式进行：lo 索引指向第一个单元格 -> hi 索引指向第二个单元格 -> 比较 -> hi 索引递增 1 直到到达数组的最后一个单元格。

然后，lo 索引加 1，然后重复上述操作。

所以最重要的是，我应该将第一个单元格与所有连续单元格进行比较，将第二个单元格与所有连续单元格进行比较，第三个等...

@@@@@@@@

如果所有数字对都是陌生人，我需要其他东西来停止递归。因此，如果所有对都是陌生人，则意味着 lo 索引和 hi 索引最终将指向最后一个单元格（因为 lo 和 hi 索引都逐渐增加，并且在所有比较结果都正常后它们到达最后一个数组单元格，即陌生人）。

下面是重载的函数：

   private static boolean checkGCD(int[] values, int lo, int hi)
    {

        if ( (gcd(values[lo], values[hi]) )!= 1 )
            return false;

        else if (lo < values.length-1 && hi < values.length-1)
                return checkGCD(values, lo, hi+1);
        else if (lo < values.length-2 && hi == values.length-1)
                return checkGCD (values, lo+1, lo+2);

        if (lo == values.length-1 && hi == values.length-1)
            return true;

         } -> Compiler says "missing return statement"**

以下是练习需要的方法，它基本上只是调用重载的方法，递归地做所有事情。

 public static boolean checkGCD(int[] values)
  {
      return checkGCD(values, 0, 1);      
  }

当我尝试编译时，我得到“缺少返回语句”，它指向重载函数中的右括号

但我确实在重载函数中使用了“return”。

请说明如何解决。我确定编译错误后，上面的重载函数仍然不行。

【问题讨论】：

这个问题似乎跑题了，因为它是关于家庭作业的。
标题一定要描述问题>>stackoverflow.com/help
@LutzHorn：家庭作业问题不是题外话。不具体、过于宽泛的问题是题外话，但这似乎不适用于这种情况。
那么 8 和 9 是陌生人，但他们也不是陌生人？这听起来不对……
嗨，恕我直言，我想了解递归的工作原理，练习只是工具。我不关心解决方案。请指教。

标签： java recursion

【解决方案1】：

您会收到编译器错误，因为如果每个 if 都失败，则该方法不会返回任何内容。解决方案是在最终的if 失败时添加适当的return 语句。

【讨论】：

【解决方案2】：

不想给出答案，但这里有一个强烈的提示：基本情况是一个包含两个元素的数组。所有较大的数组都是递归情况。

【讨论】：

或者基本情况是一个空列表；实施者的选择。

【解决方案3】：

有一个通过递归（伪代码）遍历列表的通用模式：

 Result f(List f) {
      if(f is an empty list) {
          return Result for an empty list;
      } else {
          return (Result for head of list) merged with f(tail of list)
      }
 }

由于您使用的是数组，而不是具有方便的head() 和tail() 方法的类型，因此您可以传入一个索引来说明您想要处理多少数组。当index == array.length 处理“空列表”时。

 boolean allMembersPositive(int[] array, int index) {
     if(index == array.length) {
          return true;
     } else {
          return (array[index] >=0) && (allMembersPositive(index + 1));
     }
 }

调整它以在每次递归调用中消耗两个数组项是一小步。

【讨论】：

【解决方案4】：

我可以向您保证，当您清楚地了解递归时，您的编程技能就会提高。

我建议阅读这些网址：

http://howtoprogramwithjava.com/java-recursion/

http://danzig.jct.ac.il/java_class/recursion.html

现在，让我们回到您的问题。我认为这是实现它的一种可能方式：

public class Test {

    public static void main(String[] arguments) {
    int[] strangers = { 3, 5, 7, 11 };
    int[] acquaintances = { 4, 7, 8, 9};

    boolean verifyStrangers = checkGCD(strangers);
    boolean verifyAcquaintances = checkGCD(acquaintances);

    System.out.println(verifyStrangers);
    System.out.println(verifyAcquaintances);

    }

    public static boolean checkGCD(int[] values) {
    return checkGCD(values, 0, 1);
    }

    /*
     * I'm really not sure why your professor wants this method signature: "checkGCD(int[] values, int i, int j)"
     * I'm coding what I understood from the problem.
     */
    private static boolean checkGCD(int[] values, int i, int j) {
    boolean result = true;
    if (gcd(values[i], values[j]) != 1){
        result = false;
    }
    j++;
    if (j < values.length ) {
        result = result && checkGCD(values, i, j);
    }
    return result;
    }


    private static int gcd(int n, int m) {
    if (m == 0)
        return n;
    return gcd(m, n % m);
    }

}

【讨论】：

【解决方案5】：

我设法解决了这个问题。

    public static int gcd(int n, int m)
    {
           if (m==0) 
            return n;

            return gcd(m,n % m);
    }


    private static boolean checkGCD(int[] values, int lo, int hi)
    {

  //      System.out.println("lo is " + lo + " hi is " + hi);
  //      System.out.println("");

  //      System.out.println("[lo] is " + values [lo] + " [hi] is " + values[hi]);
  //      System.out.println("");

        if ( (gcd(values[lo], values[hi]) )!= 1 )
            return false;

        if (lo < values.length-1 && hi < values.length-1)
                return checkGCD(values, lo, hi+1);

        if (lo < values.length-2 && hi == values.length-1)
            return checkGCD(values, lo+1, lo+2);

        if (lo == values.length-2 && hi == values.length-1)
          return true;  

          return true; 

    }


  public static boolean checkGCD(int[] values)
  {
      return checkGCD(values, 0, 1);      
  }

:-)

【讨论】：