Question

我正在尝试反转二维数组，但是出了点问题！翻转可以，但是不能翻转。在这里找不到错误：

public int[][] flipAndInvert(int[][] A) {
    int row = -1;
    int col = -1;
    int[][] arr = A;

    for (int i = 0; i < arr.length; i++) {
        row++;
        col = -1;
        for (int j = arr[i].length - 1; j >= 0; j--) {
            col++;
            arr[row][col] = A[i][j];
        }
    }
    for (int i = 0; i < arr.length; i++) {
        for (int j = 0; j < arr[i].length; j++) {
            if (arr[i][j] == 1) {
                arr[i][j] = 0;
            } else {
                arr[i][j] = 1;
            }
        }
    }
    return arr;
}
int[][] A = { { 0, 1, 1 },{ 0, 0, 1 },{ 0, 0, 0 } };

继续后，输出应为：反转后： {1,1,0}，{1,0,0}，{0,0,0} 翻转后： {0,0,1，}，{0,1,1}，{1,1,1}

非常感谢，问题出在这里： int [] [] arr = A; 数组的引用将传递给arr。

Answer 1

我认为是因为您正在使用此行：

arr[row][col] = A[i][j];

该数组的引用被传递给arr，因此该行：

A[row][col] = A[i][j];

等效于：

int[][] arr = new int[someRows][someCols];
//use for loop to assign the value to each element of arr

因为arr引用了A，并且它们现在都引用相同的内存位置（或者它们对于单个变量而言都是不同的名称）

您可以通过使用带有arr的new关键字然后对其进行初始化来解决此问题：

    for (int i = 0; i < arr.length; i++) {
    row++;
    col = -1;
    for (int j = arr[i].length / 2 - 1; j >= 0; j--) { //here changed arr[i].length to arr[i].length / 2
        col++; 
        arr[row][col] = A[i][j]; //for this you do not need arr and you can directly work on A and return it
    }
}

或者您可以运行for循环直到arr [i] .length / 2-1：

{{1}}

Answer 2

您的代码问题应该是此行：

int[][] arr = A;

您正在将数组A的引用分配给arr，从那时起，当您修改数组时，您将同时修改两个数组，或者最好将它们一起修改，因为它们引用的是同一地址。

Answer 3

使用apache commons lang：

    int[][] matrix = new int[3][3];
    for (int i = 0; i < matrix.length; i++) {
        matrix[i][0] = 3 * i;
        matrix[i][1] = 3 * i + 1;
        matrix[i][2] = 3 * i + 2;
    }

    System.out.println(Arrays.toString(matrix[0]));
    System.out.println(Arrays.toString(matrix[1]));
    System.out.println(Arrays.toString(matrix[2]));

    ArrayUtils.reverse(matrix);

    System.out.println(Arrays.toString(matrix[0]));
    System.out.println(Arrays.toString(matrix[1]));
    System.out.println(Arrays.toString(matrix[2]));

希望这会有所帮助。

Answer 4

使用纯Java

   private static int[] flip(int[] v) {
        int tmp;
        for (int i = 0, j = v.length - 1; j > i; i++, --j) {
            tmp = v[i];
            v[i] = v[j];
            v[j] = tmp;
        }
        return v;
    }

    private static int[] invert(int[] v) {
        for (int i = 0; i < v.length; i++) {
            v[i] =  v[i] > 0  ? --v[i] : ++v[i];
        }
        return v;
    }

    static public int[][] flipAndInvert(int[][] m) {
        for (int r = 0; r < m.length; r++) {
            m[r] =  invert( flip(m[r]) );
        }
        return m;
    }

    static void printMatrix(int[][] mat) {
        for (int[] v : mat) {
            System.out.println( Arrays.toString(v) );
        }
    }

    public static void main(String[] args) {
            int[][] m = { 
            {0, 1, 1}, 
            {0, 0, 1},
            {0, 0, 0}
        };
        m = flipAndInvert(m);
        printMatrix(m);
    }

反转二维数组

4 个答案: