java实现二维矩阵倒置

在Java中，要实现二维数组（矩阵）的倒置，你可以通过创建一个新的矩阵，并将原矩阵的元素按照行优先（即先遍历每一行再遍历下一行）的方式逐一复制到新矩阵的对应位置上，但是下标会变成反向的，也就是从最后一行的第一列开始，然后依次向前移动。

下面是一个简单的示例：

public static int[][] transpose(int[][] matrix) {
    if (matrix == null || matrix.length == 0) {
        return new int[0][0];
    }
    
    // 计算新矩阵的行数和列数
    int rows = matrix.length;
    int cols = matrix[0].length;

    // 创建一个新的矩阵用于存储结果
    int[][] transposed = new int[cols][rows];

    // 遍历原矩阵并填充新的矩阵
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            transposed[j][i] = matrix[i][j]; // 下标交换，(i, j) 对应新矩阵的 (j, i)
        }
    }

    return transposed;
}

当你调用这个`transpose`函数并传入你的矩阵时，它会返回一个转置后的矩阵。

相关问题

java二维数组倒置

要将一个二维数组进行倒置，可以通过以下代码实现：

public class ArrayReverse {
    public static void main(String[] args) {
        int[][] array = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

        // 原始数组
        System.out.println("原始数组：");
        printArray(array);

        // 倒置数组
        int[][] reversedArray = reverseArray(array);
        System.out.println("倒置数组：");
        printArray(reversedArray);
    }

    public static int[][] reverseArray(int[][] array) {
        int row = array.length;
        int col = array[0].length;
        int[][] reversedArray = new int[col][row];

        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                reversedArray[j][i] = array[i][j];
            }
        }

        return reversedArray;
    }

    public static void printArray(int[][] array) {
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }
    }
}

运行结果：

原始数组：
1 2 3 
4 5 6 
7 8 9 
倒置数组：
1 4 7 
2 5 8 
3 6 9 

用指针实现二维矩阵转置

用指针实现二维矩阵转置可以通过两种方式来实现：一种是直接在原数组上进行操作，另一种是创建一个新的数组来存储转置后的矩阵。

以下是在原数组上进行操作的实现方式：

void transpose(int *matrix, int n) {
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            // 交换matrix[i][j]和matrix[j][i]的值
            int temp = *(matrix + i * n + j);
            *(matrix + i * n + j) = *(matrix + j * n + i);
            *(matrix + j * n + i) = temp;
        }
    }
}

该函数中的参数`matrix`是一个指向二维数组首元素的指针，`n`是矩阵的行数和列数。在函数中，使用两个for循环遍历矩阵的上三角（即`i<j`的部分），并对于每个元素，交换它和对应位置上的元素的值。

如果你想创建一个新的数组来存储转置后的矩阵，可以使用以下代码：

int** transpose(int **matrix, int m, int n) {
    int **transposedMatrix = new int*[n];
    for (int i = 0; i < n; i++) {
        transposedMatrix[i] = new int[m];
        for (int j = 0; j < m; j++) {
            transposedMatrix[i][j] = matrix[j][i];
        }
    }
    return transposedMatrix;
}

该函数中的参数`matrix`是一个二维数组，`m`和`n`分别是矩阵的行数和列数。函数首先创建一个`n*m`的新数组`transposedMatrix`来存储转置后的矩阵。然后，使用两个for循环遍历原矩阵中每个元素，并将其放置到新矩阵中对应位置上。