java如何编写一个方法来反转2D数组

Question

我有个问题要解决

Write a method that takes a two-dimensional array of type integer as a parameter and return the inverse of the array (the rows become the columns and vice versa).

这就是我通过搜索所做的，但它显示了一系列错误

public static class inverse{

    public static int[][] arrayInverse(int[][] A){
        int[][] B = new int[3][3];
        for(int i=0; i<B.length/2;i++){
            for (int j=0; j<B[i].length/2;j++) {
                int swap = B[i][j];
                B[B.length - i - 1] = swap;
            }
        }
        return swap;
    }
}

}

Answer 1

需要在列和行之间替换

public class inverse {
    /**
     * The entry point of application.
     *
     * @param args the input arguments
     */
    public static void main(String[] args) {
        int ints[][] = {{1, 2, 3},
                {5, 6, 7},
                {9, 10, 11},
                {12, 13, 14}
        };
        print2D(ints);
        System.out.println("\n");
        print2D(arrayInverse(ints));
    }

    /**
     * Array inverse int [ ] [ ].
     *
     * @param A the a
     * @return the int [ ] [ ]
     */
    public static int[][] arrayInverse(int[][] A) {
        if (A.length == 0 || A[0].length == 0) {
            System.out.println("A.length==0 || A[0].length==0");
            return A;
        }
        int[][] B = new int[A[0].length][A.length];
        for (int i = 0; i < B.length; i++) {
            for (int j = 0; j < B[i].length; j++) {
                B[i][j] = A[j][i];
            }
        }
        return B;
    }

    /**
     * Print 2 d.
     *
     * @param mat the mat
     */
    public static void print2D(int mat[][]) {
        // Loop through all rows
        for (int i = 0; i < mat.length; i++) {

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

输出：

1 2 3
5.6.7
91011
12 13 14

1 5 9 12
2 6 10 13
371114

Answer 2

这里有一个普遍的解决方案。它将转置任何矩阵，包括一个参差不齐的矩阵

List<int[][]> demo = List.of(
        new int[][] { { 1 }, { 2, 3, 4 }, { 5, 6 } },
        new int[][] { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } },
        new int[][] { { 1, 2, 3, 4, 5 },
                { 6, 7, 8, 9, 10 } });

for (int[][] arr : demo) {
    System.out.println("Original");
    for (int[] b : arr) {
        System.out.println(Arrays.toString(b));
    }
    System.out.println("Transposed");
    for (int[] b : transpose(arr)) {
        System.out.println(Arrays.toString(b));
    }
    System.out.println();
}

印刷品

Original
[1]
[2, 3, 4]
[5, 6]
Transposed
[1, 2, 5]
[3, 6]
[4]

Original
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]
Transposed
[1, 4, 7]
[2, 5, 8]
[3, 6, 9]

Original
[1, 2, 3, 4, 5]
[6, 7, 8, 9, 10]
Transposed
[1, 6]
[2, 7]
[3, 8]
[4, 9]
[5, 10]

• 首先，找到结果行数，即源矩阵中的最大列数
• 然后简单地遍历矩阵，创建新行，并将每列的适当值复制到新行。由于行的长度可能不同，因此会进行检查以确保当前行中存在该值
• 然后将适当长度的行复制到转置的行中

public static int[][] transpose(int[][] nums) {
    int maxRows = nums[0].length;
    for (int[] ar : nums) {
        maxRows = Math.max(maxRows, ar.length);
    }
    int[][] trans = new int[maxRows][];
    for (int r = 0; r < maxRows; r++) {
        int[] row = new int[nums.length];
        int cc = 0;
        for (int c = 0; c < row.length; c++) {
            if (r < nums[c].length) {
                row[cc++] = nums[c][r];
            }
        }
        trans[r] = Arrays.copyOf(row, cc);
    }
    return trans;
}

印刷品

Answer 3

首先，如注释中所述，任务是transpose输入数组行变为列，反之亦然

如果输入的2D数组是正方形的（行数与列数相同），最有效的方法是交换主对角线上下的元素：a[i][j] ⇄ a[j][i]，而不使用额外的数组：

public static int[][] transposeSquare(int[][] arr) {
    for (int i = 0, n = arr.length; i < n; i++) {
        // select the elements only above the main diagonal
        for (int j = i + 1, m = arr[i].length; j < m; j++) {
            int tmp = arr[i][j];
            arr[i][j] = arr[j][i];
            arr[j][i] = tmp;
        }
    }
    return arr;
}

然而，在矩形矩阵的一般情况下，可能需要创建一个大小为M x N而不是N x M的新数组/矩阵，并以适当的顺序从输入中复制值（此时无需交换）：

public static int[][] transpose(int[][] arr) {
    int[][] result = new int[arr[0].length][arr.length];
    for (int i = 0, n = arr.length; i < n; i++) {
        for (int j = 0, m = arr[i].length; j < m; j++) {
            result[j][i] = arr[i][j];
        }
    }
    return result;
}