方法在Java中对2D数组中的列进行就地反转

给出了一个

2D数组

编写列反转方法的问题。如果可能，在适当的位置执行

我已经实现了，它工作得很好。但是它没有

到位

。它使用

辅助存储

，是否可以在不使用矩阵的情况下反转2D数组的列

Here is my code:
public static int[][] reverseColumns(int[][] matrix){
        int rows=matrix.length;
        int cols=matrix[0].length;
        int temp=0;

        int[][] result= new int[rows][cols];

        for (int row=rows-1; row >=0; row--){
            for (int col=0;col<cols;col++){
                result[row][col]=matrix[temp][col];
            }
            temp++;
        }
        return result;
    }

  public static void print2DArray(int[][] result){
    for (int i=0; i < result.length;i++){
        System.out.println(Arrays.toString(result[i]));

    }
}

public static void main(String[] args)
    {
        int[][] matrix = {
                {1,2,3,4},
                {5,6,7,8},
                {9,10,11,12},
                {13,14,15,16}
            int[][] result = reverseColumns(matrix);
    print2DArray(result);       
    System.out.println()
        };

---

诀窍是有一个计数器变量，比如

行

然后只循环到数组的中间，然后执行以下操作

tmp = matrix[row];
matrix[row]=matrix[rows-1-row];
matrix[rows-1-row]=tmp;

其中，

行

是总计数

我将让您了解

tmp

的类型

这只是使用一个恒定的辅助存储器，
因为

tmp

只是一个引用（Java中有4个字节）

---

这可能有助于您进行就地交换：

private void swap(int[][] A, int row1, int col1, int row2, int col2) {
    int tmp = A[row1][col1];
    A[row1][col1] = A[row2][col2];
    A[row2][col2] = tmp;
}

---

我已经按照您的建议遵循了cols和rows反转的语义：

   1 2 3                                     7 8 9
   4 5 6    _______column reversal_______    4 5 6 (vertically reversed) 
   7 8 9                                     1 2 3   



   1 2 3                                     3 2 1
   4 5 6    _______row reversal__________    6 5 4 (horizontally reversed) 
   7 8 9                                     9 8 7   

可以就地执行两个

：

对于

水平（行反转）

来说，这很简单。对于

垂直（列反转）

，需要更多的理解。这里的方法是；举一个例子

矩阵

，试着按照步骤进行操作，你就会明白了

public static void reverseColumnsInPlace(int[][] matrix){
        for(int col = 0;col < matrix[0].length; col++){
            for(int row = 0; row < matrix.length/2; row++) {
                int temp = matrix[row][col];
                matrix[row][col] = matrix[matrix.length - row - 1][col];
                matrix[matrix.length - row - 1][col] = temp;
            }
    }
}

public static void reverseRowsInPlace(int[][] matrix){

    for(int row = 0; row < matrix.length; row++){
        for(int col = 0; col < matrix[row].length / 2; col++) {
            int temp = matrix[row][col];
            matrix[row][col] = matrix[row][matrix[row].length - col - 1];
            matrix[row][matrix[row].length - col - 1] = temp;
        }
    }
}

公共静态无效反向列位置（int[][]矩阵）{
对于（int col=0；col<矩阵[0]。长度；col++）{
对于（int row=0；row

为什么要这样做？是否存在性能问题？如果可以接受，则可以打印反转的列。Y代码反转数组的列。请勾选“倒转”列表示最后一列变为第一列，第二列变为第二列，等等。至少我是这样理解的。代码反转每列中的元素，这意味着它反转行。检查您的输入/输出。我想象它是每个列垂直向下运行，所以reverse column意味着反转这条真实的行，这就是我的代码所做的。但是你的建议告诉我，反转数组列表中的每个数组就是反转列，我把它想象成行…没关系，我们谈论的是同一件事。如果这就是你的理解，你的代码是好的，你只需要使用恒定数量的辅助存储。我得到了“通过你的上述解释反转行”，而不使用辅助存储工作。但我的问题是关于“反转列”，如果没有辅助项，我很难编写

   1 2 3                                     7 8 9
   4 5 6    _______column reversal_______    4 5 6 (vertically reversed) 
   7 8 9                                     1 2 3   



   1 2 3                                     3 2 1
   4 5 6    _______row reversal__________    6 5 4 (horizontally reversed) 
   7 8 9                                     9 8 7   

public static void reverseColumnsInPlace(int[][] matrix){
        for(int col = 0;col < matrix[0].length; col++){
            for(int row = 0; row < matrix.length/2; row++) {
                int temp = matrix[row][col];
                matrix[row][col] = matrix[matrix.length - row - 1][col];
                matrix[matrix.length - row - 1][col] = temp;
            }
    }
}

public static void reverseRowsInPlace(int[][] matrix){

    for(int row = 0; row < matrix.length; row++){
        for(int col = 0; col < matrix[row].length / 2; col++) {
            int temp = matrix[row][col];
            matrix[row][col] = matrix[row][matrix[row].length - col - 1];
            matrix[row][matrix[row].length - col - 1] = temp;
        }
    }
}