Question

嘿伙计们，我在写这部分代码时遇到了问题。我必须使用递归来总结这个二维数组的元素。我理解我需要做什么，但我不了解如何实现它来逐步完成数组。我一直收到错误。有人可以帮帮我吗？

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        int[][] a;
        a = new int[3][4];
        int sum = 0;

        System.out.println("Enter 12 numbers: ");
        Scanner scan = new Scanner(System.in);

        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 4; j++) {
                a[i][j] = scan.nextInt();
            }
        }
        sum = sum2D(a, 0, 0);
        System.out.println("The sum of the array: " + sum);

    }

    public static int sum2D(int a[][], int row, int col) {
        if (row == a.length-1) {
            return a[row][col];
        }

        if (col == a[row].length-1) {
            return a[row][col] + sum2D(a, row++, 0);
        }

        return a[row][col] + sum2D(a, row, col++);
    }

}

Answer 1

当您需要递归解决方案时，基本计划是寻找一种方法来解决问题，使其包含一个小问题（或多个小问题），看起来就像原始问题一样，只是更小

对于2-D阵列，这可能很棘手。假设你的数组看起来像

1    2    3    4    5
6    7    8    9    10
11   12   13   14   15

首先想到的可能是编写一个递归函数，该函数需要row和column，并将a[row][column]添加到 rest的总和的数组。问题是，例如，如果row=0和column=0，则问题是＆＃34;＆＃34;你必须解决看起来像

      +---------------------+
    1 |  2    3    4    5   |
  +---+                     |
  | 6    7    8    9    10  |
  | 11   12   13   14   15  |
  +-------------------------+

（请原谅不良的ASCII艺术）。所以现在你的小问题根本不像一个数组，而是一些奇怪的多边形。通过编写像

这样的递归函数，仍然可以使用这种方法

int sumOfWeirdShapedSectionOfArray(int[][] array, int firstRow, int firstCol)

但那肯定是滥用递归。更好的是将阵列分解为第一行＆＃34;和＆＃34;其余的行＆＃34;：

    1    2    3    4    5
  +-------------------------+
  | 6    7    8    9    10  |
  | 11   12   13   14   15  |
  +-------------------------+

（或者您可以将其分解为＆＃34;最后一行＆＃34;以及＆＃34;其余行＆＃34;。）

现在，你的小问题看起来很像原来的问题，对吧？所以你的答案是＆＃34;数组中元素的总和是第一行的总和加上较小数组中从下一行开始的元素之和＆＃34;。第二部分是递归调用。第一部分，即第一行的总和，需要您调用一个新函数来添加一行;因为你仍然不允许使用循环，所以＆＃34;加一行＆＃34;函数也是递归的，但这很容易。

说完这一切之后，没有人会在现实世界中使用递归来解决这个问题。但是，如果要熟悉递归，以便可以在需要时使用它，那么这种思维过程就是你需要遵循的。

Answer 2

要做到没有递归，只需要两个嵌套的for循环：

int sum = 0;
for(int i=0;i<array.length;i++)
   for(int j=0;j<array[i].length;j++)
      sum += array[i][j];
return sum;

用递归来做：

int sum2D(int a[][], int row, int col) {

    if (row == a.length-1)
        return a[row][col];

    if(col == a[row].length-1)
        return a[row][col]+sum2D(a,row+1,0);

    return a[row][col]+sum2D(a,row,col+1);
}

基本上你做同样的事情：浏览每一行和每一行并将它们加在一起。

但请注意，是您可以使用的递归例程的限制。如果你递得太深，你将收到StackOverflow错误。

Answer 3

以上代码中的基本条件错误：

以下是有效的代码：

 public static int addMatrix(int a[][],int r,int c){
    if(r==a.length-1 && c==a[r].length-1)
        return a[r][c];
    if(c==a[r].length-1)
        return a[r][c]+addMatrix(a,r+1,0);
    return a[r][c]+addMatrix(a,r,c+1);  
    }

Answer 4

这里是等效的“ C”程序，但是对于行4的数量和列1的数量，为什么会得到不可预测的结果？

   #include <stdio.h>
   #include <string.h>
   #include <conio.h>
   int row,col;
   main()
   {


    int a[][];
    int nrow,ncols,summ = 0;
    printf("Enter No of Rows:");
    scanf("%d",&nrow);
    printf("Enter No of Columns:");
    scanf("%d",&ncols);
    int arraylength,rowlength;

     printf("Enter %d numbers: \n",nrow*ncols);
     for (int i = 0; i < nrow; i++) {
        for (int j = 0; j < ncols; j++) {
            scanf("%d",&a[i][j]);
        }
    }
    arraylength=sizeof(a)/sizeof(int);
    summ = sum(a,0, 0,nrow,ncols);
    printf("\n The sum of the array: %d ",summ);
    getch();

   }

   int sum( int a[row][col],int row,int col,int RowLen,int ColLen)
   {

    if ((row == RowLen-1) && (col==(ColLen)-1)) {
        return a[row][col];
    }

    if (col == (ColLen)-1)
    {             
        return (a[row][col] + sum(a,row+1,0,RowLen,ColLen));
    }

       return (a[row][col] + sum(a,row, col+1,RowLen,ColLen));
    }

使用递归添加二维数组的元素

4 个答案: