在Java中递归查找数组中的数字总和

我知道通过迭代而不是递归来查找数组中的数字之和要容易得多，但是如果我使用递归来编写这样一个函数，这段代码会有什么问题

public static double sum (double[] a) {
    if (a.length == 0)
        return 0.0;
    else{
        return sumHelper (a, 1, a[0]);
    }
}
private static double sumHelper (double[] a, int i, double result) {
    if (i < a.length) {
        result = result + sumHelper (a, i + 1, result);
    }
    return result;
}

公共静态双和（双[]a）{
如果（a.length==0）
返回0.0；
否则{
返回（a，1，a[0]）；
}
}
私有静态双sumHelper（double[]a，int i，double result）{
如果（i

---

一切运行都没有错误，但在我测试它时没有返回正确的总和。

将I的值初始化为0，因为您正在传递1。 或者试试这个

public static void main(String args[]){
    double a[]=new double[10];
    a[0]=123;
    a[1]=123;
    a[2]=123;
    a[3]=123;
    a[4]=123;
    a[5]=123;
    a[6]=123;
    a[7]=123;
    a[8]=123;
    a[9]=123;
    System.out.println(sum(a));
}

---

将i的值初始化为0，因为您正在传递1。 或者试试这个

public static void main(String args[]){
    double a[]=new double[10];
    a[0]=123;
    a[1]=123;
    a[2]=123;
    a[3]=123;
    a[4]=123;
    a[5]=123;
    a[6]=123;
    a[7]=123;
    a[8]=123;
    a[9]=123;
    System.out.println(sum(a));
}

---

主方法声明有问题：

public static void main(String args[]){
        double a[]=new double[10];
        a[0]=123;
        a[1]=123;
        a[2]=123;
        a[3]=123;
        a[4]=123;
        a[5]=123;
        a[6]=123;
        a[7]=123;
        a[8]=123;
        a[9]=123;
        System.out.println(sum(a));
    }

---

主方法声明有问题：

public static void main(String args[]){
        double a[]=new double[10];
        a[0]=123;
        a[1]=123;
        a[2]=123;
        a[3]=123;
        a[4]=123;
        a[5]=123;
        a[6]=123;
        a[7]=123;
        a[8]=123;
        a[9]=123;
        System.out.println(sum(a));
    }

---

如果只使用一个方法对数组中的所有数字进行递归求和，那么就可以这样做。 公共静态void main（字符串[]args）{

double a[]=新的double[6]；//初始化它
a[0]=1；//用值填充它
a[1]=2；
a[2]=3；
a[3]=4；
a[4]=5；
a[5]=6；
System.out.println（sum（a，a.length-1））；//调用该方法并打印
}
公共静态双和（双arr[]，int n）{
if（n<0）{
返回0；
}否则{
返回arr[n]+sum（arr，n-1）；//magic
}
}

如果您只使用一个方法对数组中的所有数字进行递归求和，那么您就可以这样做。 公共静态void main（字符串[]args）{

double a[]=新的double[6]；//初始化它
a[0]=1；//用值填充它
a[1]=2；
a[2]=3；
a[3]=4；
a[4]=5；
a[5]=6；
System.out.println（sum（a，a.length-1））；//调用该方法并打印
}
公共静态双和（双arr[]，int n）{
if（n<0）{
返回0；
}否则{
返回arr[n]+sum（arr，n-1）；//magic
}
}

我已经用[0]考虑了数组（0）的第一个索引。因此，我希望获取初始索引，并添加从0开始的每个索引。这就是为什么我将它初始化为1。我已经用[0]考虑了数组（0）的第一个索引。因此，我希望获取初始索引，并添加从0开始的每个索引。这就是为什么我将它初始化为1。我包含的代码不是整个文件。我确实初始化了不同的数组用作测试，还有一个已经正确声明的主方法。然而，文件的其余部分已经给出，只有我包含的代码片段是我添加到文件中的。我确信问题出在我上面包含的代码中。正如我所说，一切都正确编译和运行，我只是得到了一个与预期不同的结果。例如，当使用包含-3和5的数组对其进行测试时，总和为2，但返回的是-6。我包含的代码不是整个文件。我确实初始化了不同的数组用作测试，还有一个已经正确声明的主方法。然而，文件的其余部分已经给出，只有我包含的代码片段是我添加到文件中的。我确信问题出在我上面包含的代码中。正如我所说，一切都正确编译和运行，我只是得到了一个与预期不同的结果。例如，当用一个包含-3和5的数组测试它时，和应该是2，但是它返回-6。注意循环不变量谢谢！正是我想要的。这是一个更好的方法，不包括第三个参数。注意循环不变量谢谢！正是我想要的。这是一个更好的方法，不包括第三个论点。谢谢！然而，在这种情况下，我更愿意将其作为两个独立的方法。我知道把它浓缩成一种方法会更简单更有效。谢谢！然而，在这种情况下，我更愿意将其作为两个独立的方法。我理解将其压缩成1个方法会更简单、更有效。在每次递归调用中将问题缩减1将导致堆栈大小为O（n）。如果有可能需要处理大型数组，最好编写

sumHelper

以返回某个范围的和。如果范围的长度为1，则返回该元素的值。否则，将范围一分为二，递归调用每一半的

sumHelper

，并返回结果的总和。这不会减少工作量，但会使堆栈增加O（logn），并允许您处理更大的数组。在每次递归调用中将问题减少一个将导致堆栈大小为O（n）。如果有可能需要处理大型数组，最好编写

sumHelper

以返回某个范围的和。如果范围的长度为1，则返回该元素的值。否则，将范围一分为二，递归调用每一半的

sumHelper

，并返回结果的总和。这不会减少工作量，但会使堆栈增加O（logn），并允许您处理更大的阵列。