遞歸求和一個數組中的整數

Question

我有一個程序，我正在嘗試使用遞歸返回數組中所有整數的總和的類。這是我的計劃至今：

public class SumOfArray { 

private int[] a; 
private int n; 
private int result; 

    public int sumOfArray(int[] a) { 

     this.a = a; 
     n = a.length; 

     if (n == 0) // base case 
     result = 0; 
     else 
      result = a[n] + sumOfArray(a[n-1]); 

     return result; 

    } // End SumOfArray method 

} // End SumOfArray Class 

但我發現了三個誤差這是所有相關的，我相信，但我想不通爲什麼它是找到一個類型爲null：

SumOfArray.java:25: sumOfArray(int[]) in SumOfArray cannot be applied to (int) 
    result = a[n] + sumOfArray(a[n-1]); 
        ^
SumOfArray.java:25: operator + cannot be applied to int,sumOfArray 
    result = a[n] + sumOfArray(a[n-1]); 
      ^
SumOfArray.java:25: incompatible types 
found : <nulltype> 
required: int 
    result = a[n] + sumOfArray(a[n-1]); 
       ^
3 errors 

Answer 1

的解決方案是簡單的比看起來，試試這個（假定一個具有非零長度數組）：

public int sumOfArray(int[] a, int n) { 
    if (n == 0) 
     return a[n]; 
    else 
     return a[n] + sumOfArray(a, n-1); 
} 

這樣稱呼它：

int[] a = { 1, 2, 3, 4, 5 }; 
int sum = sumOfArray(a, a.length-1); 

Answer 2

問題是a[n-1]是int，而sumOfArray預計數組的int。

提示：您可以通過使sumOfArray取數組和開始（或結束）索引來簡化事情。

Answer 3

a是一個int數組。因此a[n-1]是int。您正在傳遞一個int至sumOfArray，它需要一個數組而不是int。

Answer 4

a[n-1] 

從n-1獲取int，而不是從0到n-1的數組。

嘗試使用

Arrays.copyOf(a, a.length-1); 

代替

Answer 5

試試這個，如果你不想通過數組的長度：

private static int sumOfArray(int[] array) { 

     if (1 == array.length) { 
      return array[array.length - 1]; 
     } 

     return array[0] + sumOfArray(Arrays.copyOfRange(array, 1, array.length)); 
    } 

Offcourse你需要檢查，如果數組爲空。

Answer 6

這是一個複雜度爲O（N）且僅帶有輸入參數A []的遞歸解決方案。
您可以在此解決方案中專門處理null和空（0長度）的情況作爲其返回0。在這種情況下，你也拋出Exception。

---

/* 
* Complexity is O(N) 
*/ 
public int recursiveSum2(int A[]) 
{ 
    if(A == null || A.length==0) 
    { 
     return 0; 
    } 
    else 
    { 
     return recursiveSum2Internal(A,A.length-1); 
    } 
} 
private int recursiveSum2Internal(int A[],int length) 
{ 
    if(length ==0) 
    { 
     return A[length]; 
    } 
    else 
    { 
     return A[length]+recursiveSum2Internal(A, length-1); 
    } 
} 

Answer 7

這個怎麼樣遞歸解決方案？你創建一個包含第二個到最後一個元素的較小的子數組。該遞歸繼續，直到數組的大小變爲1

import java.util.Arrays; 

public class Sum { 
    public static void main(String[] args){ 
     int[] arr = {1,2,3,4,5}; 
     System.out.println(sum(arr)); // 15 
    } 

    public static int sum(int[] array){ 
     if(array.length == 1){ 
      return array[0]; 
     } 

     int[] subArr = Arrays.copyOfRange(array, 1, array.length); 
     return array[0] + sum(subArr); 
    } 
} 

Answer 8

private static int sum(int[] arr) { 
    // TODO Auto-generated method stub 
    int n = arr.length; 

    if(n==1) 
    { 
     return arr[n-1]; 
    } 

    int ans = arr[0]+sum(Arrays.copyOf(arr, n-1)); 

    return ans; 
}