有點新的遞歸方法，我不知道爲什麼這不起作用

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（）方法。