Question

我是算法初学者，刚开始阅读Michael Rich的“Java中的数据结构和算法”。他提出了一个名为“BinarySum（A，i，n）”的基于二进制递归的函数。

 BinarySum(A,i,n)
 Input:An array A and integer i and n
 Output: The sum of n integers in A starting and index i
 if n==1 then
  return A[i];
 return BinarySum(A,i,[n/2])+BinarySum(A,i+[n/2],[n/2])

我们最初将通过BinarySum（A，0，n）开始调用。

在下面的练习中，有一个问题要求我描述一种使用递归来添加n * n二维整数数组的所有元素的方法。他给出的提示是我们可以通过使用两个递归调用来遵循BinarySum（A，i，n）的样式。

我坚持这个，我可以想到解决方案就像循环遍历n * n矩阵的每一行，然后对于每一行，我调用BinarySum（A，i，n），然后求和。但我真的不认为这是本练习的目的。

考虑过其他可能的解决方案，但我仍坚持使用递归来实现它。专家可以给出一些提示吗？感谢。

Answer 1

使用java代码，

这是2D矩阵的BinarySum，假设你有n1行和n2列，因此，总和将等于n1 / 2个第一行和n1 / 2个最后一行的总和。对于每一行，总和将分为n2 / 2个第一列和n2 / 2个最后一列，

public static void main(String[] args) {

    int[][] data = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
    System.out.println(sum(data, 0, 3, 0, 4));
}

public static int sum(int[][] data, int x, int n1, int y, int n2) {

    if (n1 == 1 && n2 == 1) {
        return data[x][y];
    }
    if (n1 == 1) {
        return sum(data, x, n1, y, (n2 / 2)) + sum(data, x, n1, y + (n2 / 2), n2 - (n2 / 2));
    } else {
        return sum(data, x, (n1 / 2), y, n2) + sum(data, x + (n1 / 2), n1 - (n1 / 2), y, n2);
    }
}

输出：

Answer 2

我不会给你伪代码。我想你可以在解释后轻松搞清楚。使用类似的递归技术有多种方法可以实现这一点。

对于二维数组，您的递归现在分支为4个子分支而不是2.您可以将此视为将网格划分为4个子网格并递归地对它们求和。这实际上意味着，现在您的递归函数BinarySum（A，i，j，n）将从单元格（i，j）开始对n行和n列求和（确保在n处的适当位置处理地板和天花板）很奇怪。
另一种看待这种情况的方法是使用两个函数，一个用于递归求和行，另一个用于递归求和列。因此，您的BinarySum（A，i，n）将递归地对从行号i到行号n的所有行求和。当n = 1时，您的问题会减少到对1-D数组的所有元素求和（使用您已经计算过的函数）。

Answer 3

public static int deepSum(int[][] data){
    //n*n
    return deepSum(data, data.length, data.length);
}
private static int deepSum(int[][] data, int n, int m){
    if (n ==1)
        return deepSumCol(data ,m, 0);
    else
        return  deepSum(data, n-1,m) + deepSumCol(data, m, n-1);
}

private static int deepSumCol(int[][] data, int n ,int m){
    if (n ==1)
        return data[m][0];
    else{
        return  deepSumCol(data, n -1,m) + data[m][n-1];
    }

}

Answer 4

  // Break the 2D array into shorter arrays via rows
  // Initial n is A.length - 1 
  public int binarySum(int[][] A, int j, int n){
    if(j > n) return 0;
    if(j == n ) return binarySum(A[j], 0, A[j].length - 1);
    int m = (j + n) / 2;
    return binarySum(A, j, m) + binarySum(A, m + 1, n);
  }

  //Break the array into smaller arrays via cols
  public int binarySum(int[] A, int i, int n){
    if( i > n) return 0;
    if(i == n) return A[i];
    int m = (i + n) / 2;
    return binarySum(A, i, m) + binarySum(A, m+1, n);
  }

Answer 5

工作 C++ 代码

int main() {
    int arr[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    cout << arraySum(arr, 2, 2, 2) << endl;
    return 0;
}
/*
 * arr: 2d array data
 * i = current row index(will start from rowSize - 1)
 * j = current column index(will start from columnSize - 1)
 * mSize = Column Size
*/
int arraySum(int arr[3][3], int i, int j, int mSize ) {
    if (i == 0 && j == 0) {
        return arr[i][j]; // condition 3
    }
    if (j == 0) {
        return arr[i][j] + arraySum(arr, i - 1, mSize, mSize); // condition 2
    }
    else {
        return arr[i][j] + arraySum(arr, i, j - 1, mSize); // condition 1
    }
}

基本解释：

函数arraySum从[n-1][m-1]位置开始到[0][0]

End<-1 | 2 | 3
     ---------
     4 | 5 | 6
     ---------
     7 | 8 | 9 <- start

(i = 2, j = 2) 条件 1 将被执行： a[2][2] + a[2][1] + (a[2][0] 因为 col val 是 0 那么我们将转到条件 2)
条件2改变后(i = 1, j = 2) a[1][2] + a[1][1] + (a[1][0] 因为 col val 是 0 那么我们将转到条件 2)
条件2改变后(i = 0, j = 2) a[0][2] + a[0][1] + (a[0][0] 因为 row 和 col 都是 0 我们将满足条件 3)

沃拉！回答

递归求和二维数组的元素？

5 个答案:

基本解释：