有点新的递归方法，我不知道为什么这不起作用

Question

我正在做一个类的任务，但我不知道为什么我为这两个方法编写的代码不起作用。

对于第一种方法，我试图将数组中的当前位置与下一个位置进行比较，如果下一个位置较大，则它将变为最大。换句话说，当前位置的整数变成最大。使用递归方法调用通过数组后，它将返回数组中最大的int值。

// This method takes an integer array as well as an integer (the starting index) and returns the largest number in the array. 
public int largestRec(int[] arr, int pos) 
{ 
    // TODO: implement this method 
    int largest = arr[pos]; 
     if(pos == arr.length-1) 
    { 
     return largest; 
    } 
    else 
    { 
     if(arr[pos] < arr[pos+1]) 
     { 
      largest = arr[pos+1]; 
     } 
     else 
     { 
      largest = arr[pos]; 
     } 
     pos++; 
     largestRec(arr, pos); 
    } 
    return largest; // replace this statement with your own return 
} 

第二种方法。我想要做的是让它通过递归方法调用传递一个较小版本的字符串，然后当测试类调用方法时，它将打印出字符串的反向。

// This method reads a string and returns the string in the reversed order. 
public String reverseStringRec(String s) 
{ 
    // TODO: implement this method 
    String reverse; 
    int pos = 0; 
    if(s=="" || s.length() <= 1) 
    { 
     return s; 
    } 
     else 
    { 
     reverse = reverseStringRec(s.substring(1)) + s.charAt(0); 
    } 
    return reverse; // replace this statement with your own return 
} 

我不知道如何编写代码，使之做到这一点（的任务，我只能修改方法，而不是外面的变量/方法/允许类），所以我会很感激的任何建议/帮助你可以提供。如果您需要更多信息，我会很乐意提供。谢谢。

编辑： 我的问题是，第一种方法不会返回最大。对于我的测试数组，它通常会打印第一个int，或者第二个（如果它大于第一个，但不检查其余）。对于第二个问题，我的测试课（由我的教授提出）给出了'串索引超出范围'的消息，我不知道如何解决这个问题。我看着Jason的建议，并将建议的解决方案，但它似乎并没有工作我的情况

EDIT2：reverseStringRec（）的新版本现在可现在我需要修复largestRec（）问题仍然是开放的，如果任何人都可以提供任何帮助

。

编辑3：虽然我修复了reverseStringRec（），但是有人给出了一个包含for循环的答案，我没有提到我不能使用循环来完成这个任务，所以我为给您带来的不便表示歉意。如果您需要查看它现在产生的结果，可以使用下面的最大记录（）。

试验3：最大（10）==> [传递] 预期：10个 此致：10

测试4：最大（10，20，30，40，50，60）==> [失败] 预期：60个 此致：20

测试5：最大（70，20，30，40，50，10）==> [传递] 预期：70个 此致：70

测试6：最大（70，20，100，40，50，10）==> [失败] 预计：100 你的：70

编辑4：找到两种方法的解决方案。对于largestRec（），请看下面提供的解决方案。对于reverseStringRec（），您可以使用本文中的或以下建议的之一。

Answer 1

查看这些找到最大数字并反转字符串的方法。你的解决方案非常接近。这是我将如何实现这些。你需要在索引中跟踪数组的最大数量，否则你可以做的就是传入第一个数字并假定它是最大的数字，并且每次找到最大的数字时，一旦到达数组的末尾，就返回最大。

public String reverseString(String str) 
{ 
    if(str.length()==1){ 
     return str; 
    } 
    return str.charAt(str.length() - 1) + reverseString(str.substring(0, str.length() - 1)); 

} 
// initialize pos to 0 
public int getLargest(int[] arr, int pos) 
{ 
    int largest = arr[pos]; 
    if (pos + 1 >= arr.length) { 
     return largest; 
    } 

    int second = getLargest(arr, pos + 1); 
    return largest > second ? largest : second; 
} 

Answer 2

逆转字符串用递归方法，你可以这样来做：公共

static String reverseStr(String str) { 
     if (str.length() == 1) 
      return str; 
     else 
      return str.charAt(str.length()-1) + reverseStr(str.substring(0, str.length()-1)); 
    } 

    public static void main(String[] args) { 
     System.out.println(reverseStr("String to be reversed")); 
    } 

另一个简单的办法扭转一个字符串（不递归）：

public static String reverseStringRec(String s) { 
     String reverse = ""; 
     int pos = 0; 
     for (int i = s.length()-1; i >= 0; i--) { 
      reverse += s.charAt(i); 
      pos++; 
     } 
     return reverse; 
    } 

    public static void main(String[] args) { 
     System.out.println(reverseStringRec("String to be reversed")); 
    } 

为了您的第一部分的问题，这里是解决方案：

static int findMax(int[] arr, int length) { 
     if (length == 1) { 
      return arr[0]; 
     } 
     return max(findMax(arr, length - 1), arr[length - 1]); 
    } 

    private static int max(int num1, int num2) { 
     return num1>num2 ? num1 : num2; 
    } 

    public static void main(String[] args) { 
     int[] arr = {10, 20, 3, 55, 200, 33}; 
     System.out.println(findMax(arr, arr.length)); 
    } 

Answer 3

就在蝙蝠身上，问题与第二种方法。在它里面，你递归地调用reverseString方法，并且它的参数是一个子字符串。然而，在这个子字符串中，你试图使子字符串比原始参数s更长 - 实质上，通过包含s.length（）+ 1，substring（）方法尝试创建一个子字符串，其索引为s .length（）+ 1，不存在。

对于实际反转方法的字符串输入，我强烈推荐使用charAt（）方法。