使用递归对二维数组中的整数求和？答案

【问题标题】：Sum integers in 2d array using recursion?使用递归对二维数组中的整数求和？
【发布时间】：2011-04-10 23:23:28
【问题描述】：

我需要一些帮助来解决这个问题。我必须使用递归对二维数组中的所有整数求和。以下是我自己设法做的事情，但我被困住了。此代码生成总和 14，应该是 18。

public class tablerecursion {
    public static void main(String[] args) {
        int[][] tabell = new int[][] { { 1, 2, 3 }, { 3, 2, 1 }, { 1, 2, 3 } };
        int sum = rec(tabell, 2, 2);
        System.out.println(sum);
    }

    static int rec(int[][] table, int n, int m) {
        if (m == 0)
            return table[n][0];
        if (n == 0)
            return table[0][m];
        System.out.println("n:" + n + "  m:" + m);

        return rec(table, n - 1, m) + rec(table, n, m - 1);
    }
}

有什么建议吗？基本情况是错误的吗？还是递归方法不对？

【问题讨论】：

标签： java arrays recursion multidimensional-array

【解决方案1】：

我会使用两个函数来解决这个问题。首先创建一个可以递归地对单个 (1d) 数组求和的函数。编写一个对外部数组递归求和前一个函数的函数。

请记住，table[N] 本身就是一个数组。您不必一次性访问所有内容。

【讨论】：

设 sum1 是递归求和单个一维数组的函数。那么 sum2 可以是（1）创建一个适当大小的数组，（2）使用 sum1 用一维数组的总和填充数组，（3）使用 sum1 计算数组的总和。

【解决方案2】：

你的递归逻辑错了。

你得到 14 因为你打电话

f(2,2)=f(2,1) + f(1,2)= (f(2,0)+f(1,1)) + (f(1,1)+f( 0,2))

f(0,2) 是你的基本情况，3 f(0,2) 是您的基本情况，1 f(1,1) = f(0,1)+f(1,0)=2+3=5

所以总和是 3+1+5+5=14

递归 this 的正确逻辑是作为 single 递归函数：

以坐标 (x,y) 开始并以 (z,w) 结束的 2x2 数组的总和是 3 个事物的总和：

  xxxxxxxxxx
  xxxxxxxxxx
  xxxxxxxxxx
  yyyyyyyyyN

由除最后一行之外的所有行组成的数组的总和（上例中的 xxxx-s）所以 (x,y) 到 (z,2-1)。
由 LAST 行组成的数组的总和（右下角除外 - 示例中为 yyyyy-s）所以，(x,w) 到 (z-1,w)
坐标 (z,w) 处的数字
基本情况是，如果 y>w（零行），则总和为零；如果 x

这实际上是一个双重递归，理想情况下。一种是使用辅助“添加一行”函数递归地计算所有行的总和 - 当然这也是递归实现的。

【讨论】：

【解决方案3】：

其他几个答案建议使用 1D 例程对与 2D 数组角落中的元素相邻的列和行求和

但是

将您的二维数组切割成四个更小的二维数组并以这种方式递归同样有效。停止条件当然是当输入是一个 1x1 二维数组时，答案是微不足道的。

跟进

除非数组尺寸为 2^m x 2^m ，否则这会遇到障碍；其他任何东西，迟早您会遇到 Nx1 或 1xN 输入，您根本无法将其切成四个子阵列。所以你最终不得不处理一维输入。

【讨论】：

如果我正确理解你的答案，它也会遇到参差不齐的数组 int [][] table = { { 1 , 2 , 3 } , { 1 , 2 } }

【解决方案4】：

请看这里是我要提交的内容，并指出递归解决方案不适用：

public static void Main()
{
        var a = new int[][] {  new int[] {1,2,3},
                               new int[] {3,2,1},
                               new int[] {1,2,3}  }; 
        int result = a.Sum(row => row.Sum());
        Console.WriteLine(result);
}

做对比简单地认为对要好。

【讨论】：

【解决方案5】：

这是一个可能的解决方案示例。如果 java 编译器可以优化 tail recursion 那么它将与迭代解决方案一样有效。现在它非常积极地吃堆栈。

public static long countSum (int[][] matrix) {
    if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
        return 0;
    }
    return countSum (matrix, 0, 0, 0, matrix.length, matrix[0].length);
}

private static long countSum (int[][] matrix, long acc, int curI, int curJ, int maxI, int maxJ) {
    if (curI >= maxI) {
        return acc;
    }
    if (curJ >= maxJ) {
        return countSum(matrix, acc, curI + 1, 0, maxI, maxJ);
    }
    return countSum(matrix, acc + matrix[curI][curJ], curI, curJ + 1, maxI, maxJ);

}

【讨论】：

【解决方案6】：

public int sumarmatriz(int matriz[][],int i,int j)
{
    if(i==0 && j==0){
        return matriz[i][j];
    }
    else if(j==0){
        return sumarmatriz(matriz,i-1,matriz.length-1)+matriz[i][j];
    }
    else{
        return sumarmatriz(matriz,i,j-1)+matriz[i][j];
    }
}

【讨论】：

请编辑更多信息。不建议使用纯代码和“试试这个”的答案，因为它们不包含可搜索的内容，也没有解释为什么有人应该“试试这个”。

【解决方案7】：

如果你想一口气全部访问，我觉得这个方法是你需要的：

public class Array {
  public static void main(String[] args){
    int[][] A = {{1,2,3,4},{1,2,3,4},{1,2,3,4},{1,2,3,4}};
    System.out.print(TwoDSum(A,4,4));
  }
  public static int TwoDSum(int A[][], int n,int m) {
    if(n==1 && m==1) return A[0][0];
    if(m==0){
      n--;
      m=A[n].length;
    }
    return TwoDSum(A,n,m-1)+A[n-1][m-1];
  }
}

【讨论】：