java实现矩阵转置

可以通过以下代码实现 Java 矩阵转置：

public static int[][] transpose(int[][] matrix) {
    int row = matrix.length;
    int col = matrix[0].length;
    int[][] transposedMatrix = new int[col][row];
    for (int i = 0; i < row; i++) {
        for (int j = 0; j < col; j++) {
            transposedMatrix[j][i] = matrix[i][j];
        }
    }
    return transposedMatrix;
}

其中，`matrix` 为原矩阵，`transposedMatrix` 为转置后的矩阵。我们先获取矩阵的行数和列数，然后创建一个新的矩阵 `transposedMatrix`，它的行数为原矩阵的列数，列数为原矩阵的行数。接着使用两层循环遍历原矩阵，将原矩阵中第 i 行第 j 列的元素赋值给转置矩阵中第 j 行第 i 列的元素。最后返回转置矩阵即可。

相关问题

java实现矩阵转置（附完整源码）

下面是Java实现矩阵转置的完整源码：

public class MatrixTranspose {
    public static void main(String[] args) {
        int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        int rows = matrix.length;
        int cols = matrix[0].length;

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

        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                transposedMatrix[j][i] = matrix[i][j];
            }
        }

        System.out.println("Original Matrix:");
        printMatrix(matrix);

        System.out.println("Transposed Matrix:");
        printMatrix(transposedMatrix);
    }

    public static void printMatrix(int[][] matrix) {
        for (int[] row : matrix) {
            for (int elem : row) {
                System.out.print(elem + " ");
            }
            System.out.println();
        }
    }
}

该程序首先定义了一个原始矩阵，然后计算了它的行数和列数。接着，它创建了一个新的矩阵，以便存储转置后的矩阵。然后，通过嵌套的for循环，将矩阵的元素逐个复制到新的矩阵中，但是在这里，行和列的索引被交换了。最后，程序打印出原始矩阵和转置后的矩阵。

该程序的输出如下所示：

Original Matrix:
1 2 3 
4 5 6 
7 8 9 
Transposed Matrix:
1 4 7 
2 5 8 
3 6 9 

java实现矩阵转置(附完整源码)

以下是Java实现矩阵转置的完整源码：

public class MatrixTranspose {
    public static void main(String[] args) {
        // 定义一个3行4列的矩阵
        int[][] matrix = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};

        // 输出原始矩阵
        System.out.println("原始矩阵：");
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[0].length; j++) {
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println();
        }

        // 定义一个新矩阵用于存储转置后的矩阵
        int[][] transposedMatrix = new int[matrix[0].length][matrix.length];

        // 转置矩阵
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[0].length; j++) {
                transposedMatrix[j][i] = matrix[i][j];
            }
        }

        // 输出转置后的矩阵
        System.out.println("转置后的矩阵：");
        for (int i = 0; i < transposedMatrix.length; i++) {
            for (int j = 0; j < transposedMatrix[0].length; j++) {
                System.out.print(transposedMatrix[i][j] + " ");
            }
            System.out.println();
        }
    }
}

运行结果如下：

原始矩阵：
1 2 3 4 
5 6 7 8 
9 10 11 12 
转置后的矩阵：
1 5 9 
2 6 10 
3 7 11 
4 8 12