Question

我试图垂直和水平排列一个二维数组，同时按给定值递增它。我能够弄清楚如何使用这种方法水平地做到这一点：

  public static void fillRight (int [][] fillRightArray, int step){

    int count = 0;
    for (int i = 0; i< fillRightArray.length; i++){
        for (int j = 0; j< fillRightArray[i].length; j++){
            count++;
            fillRightArray[i][j] += step*count;
          //  fillRightArray[i][j] += step*(i+1);


            System.out.print(fillRightArray[i][j] + " ");

        }
        System.out.print("\n");
    }

因此，当我打印时，水平排列看起来像这样：

2 4 6 8 10
12 14 16 18
20 22 24 26

现在对于垂直版本，我尝试了多次尝试，似乎没有任何效果。我知道它与fillRightArray非常相似，但我似乎无法弄明白。

最接近的ive是：

public static void fillDown(int [][] fillDownArray, int step){

    int count = 0;
    for (int i = 0; i<fillDownArray.length; i++){
        for (int j = 0; j< fillDownArray[i].length; j++){
            count++;
            fillDownArray[i][j] += step*(i+1);

            System.out.print(fillDownArray[i][j]+ " ");
       }
        System.out.print("\n");
    }

输出结果为：

 2 2 2 2 2
 4 4 4 4 4
 6 6 6 6 6
 8 8 8 8 8
 10 10 10 10 10

关于如何让它看起来像：

2 12 22 32
4 14 24 34
6 16 26 36
8 18 28 38
10 20 30 40

感谢您的帮助！请不要像我对java的新手一样简单地向我投票。

Answer 1

您可以简单地转置数组，如下所示

// transpose in-place
for (int i = 0; i < n; i++) {
    for (int j = i+1; j < n; j++) {
        int temp = a[i][j];
        a[i][j] = a[j][i];
        a[j][i] = temp;
    }
}

Answer 2

public static void fillRight (int [][] fillRightArray, int step){

    int count = 0;
    for (int i = 0; i< fillRightArray.length; i++){
        for (int j = 0; j< fillRightArray[i].length; j++){
            count++;
            fillRightArray[i][j] += step*count;
            System.out.print(fillRightArray[j][i] + " ");

        }
        System.out.print("\n");
    }
}

Answer 3

如果可以保证数组的第二维尺寸始终相同，则可以将计算和打印分开：

public static void fillDown(int[][] fillDownArray, int step) {
    //Calculate the values
    int count = 0;
    for (int i = 0; i < fillDownArray.length; i++) {
        for (int j = 0; j < fillDownArray[i].length; j++) {
            count++;
            fillDownArray[i][j] += step * count;
        }
    }

    //Print array
    for (int j = 0; j < fillDownArray[0].length; j++) {
        for (int i = 0; i < fillDownArray.length; i++) {
            System.out.print(fillDownArray[i][j] + " ");
        }
        System.out.println();
    }
}

Answer 4

虽然我同意关于转置作为翻转预先存在的二维数组的整洁解决方案的答案，但我不相信这回答了作者的问题，因为他正在制作的方法打算填充和显示二维数组。

对于填充和打印到控制台的任务，请考虑您需要实现的目标。

为了按照您的意愿打印二维数组，我们必须首先打印所有嵌套数组的索引0，所以fillDownArray[0][0]，fillDownArray[1][0]，fillDownArray[2][0]等

因此，鉴于我们还在打印之前填充，我们如何才能找出应该是什么价值？

假设step = 2和fillDownArray被初始化为new int[5][5]：

对于fillDownArray[0][0]，我们需要2：step (= 2)

对于fillDownArray[1][0]我们需要12：step + fillDownArray[0].length * step

对于fillDownArray[2][0]我们需要22：step + fillDownArray[0].length * step * 2

对于fillDownArray[3][0]我们需要32：step + fillDownArray[0].length * step * 3

对于fillDownArray[4][0]我们需要42：step + fillDownArray[0].length * step * 4

这里有一个模式，前两个可以重新配合以匹配后续模式：

对于fillDownArray[0][0]，我们需要2：step，它与：step + fillDownArray[0].length * step * 0

相同

对于fillDownArray[1][0]，我们需要12：step + fillDownArray[0].length，它与：step + fillDownArray[0].length * step * 1

相同

所以，如果我们认为第一维的指标是i和第二维j（即fillDownArray[i][j]），那么我们只需要替换结尾处的数字。使用i进行计算，结果为：

fillDownArray[i][j] = step + fillDownArray[0].length * step * i;

但这并不能解决问题。我们还必须考虑第二个方面。

第二个方面有类似的模式：

我会在i = 0时忽略并直接识别模式。

对于fillDownArray[1][0]，我们需要12：step + fillDownArray[0].length * step * i（与之前一样）

对于fillDownArray[1][1]我们需要14：step * 2 + fillDownArray[0].length * step * i

对于fillDownArray[1][2]我们需要16：step * 3 + fillDownArray[0].length * step * i

等

正如您所希望看到的，此处的更改模式位于计算的开头：step * n，其中n是一个从1开始并增加{{1}的数字每次我们迭代第二维时。

那么1是什么？它是n，其中j + 1位于用于第二维的变量中。

现在将这一切全部纳入实现，我们现在知道我们必须首先遍历第一维（j），然后第二维（i），这意味着第二维的迭代是外环和第一维内部。

此实现适用于所有情况下第二维长度相同的所有情况。

如何垂直排列数组而不是水平排列？

4 个答案: