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

Posted 2023-02-26

【中文标题】递归地对数组中的整数求和

【英文标题】：recursively sum the integers in an array

【发布时间】：2013-12-13 18:07:08

【问题描述】：

我有一个程序，我正在尝试为类创建一个使用递归返回数组中所有整数之和的程序。到目前为止，这是我的程序：

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

【问题讨论】：

在这种情况下，使用递归不仅更复杂，而且速度要慢得多。我认为这只是一个练习。

【参考方案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);

【讨论】：

只为课堂上的学生提供答案并不是一种好的形式。他们不学习。你需要解释什么是错的。

【参考方案2】：

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

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

【参考方案3】：

a[n-1] 

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

尝试使用

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

改为

【讨论】：

我相信你也可以使用Arrays#CopyOfRange。

认真的吗？这将（可怕地）起作用的事实并不意味着它是正确的方法。

@LuiggiMendoza Arrays.copyOf(a, a.length-1); 做了 op 期望 a[n-1] 做的事情。

是的，我知道，但是为什么要创建数组的整个副本并浪费内存和线性处理时间（这将使该算法在内存和时间上都为 O(n^2)）可以只传递一个整数值和要使用的数组的下一个元素，并保持这个算法 O(n)（在内存和时间中）？正如我在上一条评论中所说：它有效（编译、运行并获得预期结果）的事实并不意味着这是正确的方法。

【参考方案4】：

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

【参考方案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));
    

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

【参考方案6】：

这是一个复杂度为 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】：

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

【参考方案9】：

简化版：

//acc -> result accumlator, len - current length of array

public static int sum(int[] arr, int len, int acc) 
    return len == 0 ? acc :  sum(arr, len-1,  arr[len-1]+ acc); 
   
public static void main(String[] args)  
    int[] arr=  5, 1, 6, 2;
    System.out.println(sum(arr, arr.length, 0));