1

我正在尝试反转 2D 数组中的所有内容。最后一个值应该是第一个，第一个值应该是最后一个。

例如，输入

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

会返回：

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

这是我到目前为止的一些代码，但它正在返回：

9 8 3 
6 5 4 
7 2 1 

int[][] reverse = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
for(int i = 0; i <= (reverse.length / 2); i++) {
    for(int j = 0; j < (reverse[0].length / 2) + 1; j++) {
        System.out.println(i + " " + j);
        System.out.println((reverse.length-1-i) + " " + (reverse[0].length -1 -j));
        int temp = reverse[reverse.length-1-i][reverse[0].length -1 -j];
        reverse[reverse.length-1-i][reverse[0].length - 1 - j] = reverse[i][j];
        reverse[i][j] = temp;
     }
}
for(int i = 0; i < reverse.length; i++) {
  for(int j = 0; j < reverse[0].length; j++) {
       System.out.print(reverse[i][j]+" ");
  }
  System.out.println("");
}

如何解决这个问题，以便切换 3 和 7？

4

3 回答 3

1

您应该编写它以保留第一个单元格的 x/y 坐标和最后一个单元格的另一个 x/y 坐标，然后交换单元格值。分别向右/向下和向左/向上推进坐标，直到它们相遇。

优点是生成的代码也可以处理锯齿状数组。

static void test(int[][] arr) {
    for (int y1 = 0, x1 = 0, y2 = arr.length - 1, x2 = arr[y2].length - 1; y1 < y2 || (y1 == y2 && x1 < x2); ) {
        int temp = arr[y1][x1];
        arr[y1][x1] = arr[y2][x2];
        arr[y2][x2] = temp;
        if (++x1 == arr[y1].length) {
            y1++;   x1 = 0;
        }
        if (x2-- == 0) {
            y2--;   x2 = arr[y2].length - 1;
        }
    }
    for (int y = 0; y < arr.length; y++) {
        for (int x = 0; x < arr[y].length; x++) {
            if (x != 0)
                System.out.print(" ");
            System.out.print(arr[y][x]);
        }
        System.out.println();
    }
}

测试

test(new int[][] {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}});
test(new int[][] {{1, 2}, {3, 4, 5}, {6, 7, 8, 9}});

输出

9 8 7
6 5 4
3 2 1

9 8
7 6 5
4 3 2 1
于 2021-07-23T02:06:50.223 回答
0

您的代码的问题在于您正在循环 3。外循环从 0 到 1，内循环从 0 到 2，因此您只需将这些元素与“另一侧”的相应元素交换：

1 2
4 5
7 8

您实际上想将它们与另一侧的元素交换：

1 2 3
4

基本上，如果要交换元素，则需要使用元素数而不是行数和列数来找到中间点。

int rows = reverse.length;
int cols = reverse[0].length;
int total = rows * cols;
int half = total / 2; // calculate halfway point

for(int n = 0; n < half; n++) {
  // convert the nth element to a coordinate
  int i = n / cols;
  int j = n % cols;

  int temp = reverse[rows - 1 - i][cols - 1 - j];
  reverse[rows- 1 - i][cols - 1 - j] = reverse[i][j];
  reverse[i][j] = temp;
}

如果要找到行和列的中点，则应反转行，并反转每行内的元素。我实际上认为这是一种更直观的方法。

int rows = reverse.length;
int cols = reverse[0].length;

// reverse the rows
for (int i = 0 ; i < rows / 2; i ++) {
  int[] temp = reverse[i];
  reverse[i] = reverse[rows - 1 - i];
  reverse[rows - 1 - i] = temp;
}

// for each row, reverse the elements inside the rows
for (int i = 0 ; i < rows; i ++) {
  for (int j = 0 ; j < cols / 2 ; j++) {
    int temp = reverse[i][j];
    reverse[i][j] = reverse[i][cols - 1 - j];
    reverse[i][cols - 1 - j] = temp;
  }
}
于 2021-07-23T02:06:47.057 回答
0

您的内部循环需要迭代到每一行的末尾，而不是中间，并且您需要分别处理具有奇数行的数组的中间行：

static void reverse(int[][] arr)
{
    int m = arr.length;
    int n = arr[0].length;

    for(int i=0; i<m/2; i++)
        for(int j=0; j<n; j++)
            swap(arr[i], j, arr[m-1-i], n-1-j);
    
    if(m % 2 == 1) 
    {
        int[] mid = arr[m/2];
        for(int j=0; j<n/2; j++)
            swap(mid, j, mid, n-1-j);
    }
}
 


static void swap(int[] a, int i, int[] b, int j)
{
    int tmp = a[i];
    a[i] = b[j];
    b[j] = tmp;
}

测试：

int[][] arr = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
reverse(arr);       
for(int[] row : arr) System.out.println(Arrays.toString(row));

输出：

[9, 8, 7]
[6, 5, 4]
[3, 2, 1]
于 2021-07-23T03:53:06.777 回答