递归地对数组中的整数求和

I have a program that I'm trying to make for class that returns the sum of all the integers in an array using recursion. Here is my program thus far:

我有一个程序，我正在尝试为类返回使用递归返回数组中所有整数的总和。这是我迄今为止的计划：

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

But I'm getting three error which are all related, I believe, but I can't figure out why it is finding a type of null:

但我相信，我得到的三个错误都是相关的，但我无法弄清楚为什么它会找到一种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

8 个解决方案

#1

The solution is simpler than it looks, try this (assuming an array with non-zero length):

解决方案比它看起来更简单，试试这个（假设一个长度非零的数组）：

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

Call it like this:

这样叫：

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

#2

The issue is that a[n-1] is an int, whereas sumOfArray expects an array of int.

问题是a [n-1]是一个int，而sumOfArray需要一个int数组。

Hint: you can simplify things by making sumOfArray take the array and the starting (or ending) index.

提示：您可以通过使sumOfArray获取数组和起始（或结束）索引来简化操作。

#3

a[n-1]

is getting the int at n-1, not the array from 0 to n-1.

是在n-1处得到int，而不是从0到n-1的数组。

try using

尝试使用

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

instead

代替

#4

a is an int array. Thus a[n-1] is an int. You are passing an int to sumOfArray which expects an array and not an int.

a是一个int数组。因此，[n-1]是int。您正在将一个int传递给sumOfArray，它需要一个数组而不是一个int。

#5

Try this if you don't want to pass the length of the array :

如果您不想传递数组的长度，请尝试此操作：

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 you need to check if the array is empty or not.

当然你需要检查数组是否为空。

#6

This is the one recursive solution with complexity O(N).and with input parameter A[] only.
You can handle null and empty(0 length) case specifically as Its returning 0 in this solution. You throw Exception as well in this case.

这是具有复杂度O（N）和输入参数A []的一种递归解决方案。您可以处理null和empty（0 length）情况，特别是它在此解决方案中返回0。在这种情况下，您也会抛出异常。

/*
 * 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);
    }
}

#7

How about this recursive solution? You make a smaller sub-array which contains elements from the second to the end. This recursion continues until the array size becomes 1.

这个递归解决方案怎么样？您创建一个较小的子数组，其中包含从第二个到最后的元素。此递归将继续，直到数组大小变为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);
    }
}

#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;
}

#1