写一个代码，将一个3*3的矩阵逆置

以下是Python代码实现：

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

# 打印原始矩阵
print("原始矩阵：")
for row in matrix:
print(row)

# 逆置矩阵
for i in range(len(matrix)):
for j in range(i, len(matrix[i])):
matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]

# 打印逆置后的矩阵
print("逆置后的矩阵：")
for row in matrix:
print(row)

运行结果：

原始矩阵：
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]
逆置后的矩阵：
[1, 4, 7]
[2, 5, 8]
[3, 6, 9]

相关问题

C语言逆置矩阵

要逆置矩阵，可以先将矩阵进行转置，再将每一行的元素逆序排列。以下是一个示例代码：

#include <stdio.h>

void transpose(int mat[][3], int row, int col) {
    int temp;
    for (int i = 0; i < row; i++) {
        for (int j = i+1; j < col; j++) {
            temp = mat[i][j];
            mat[i][j] = mat[j][i];
            mat[j][i] = temp;
        }
    }
}

void reverse(int mat[][3], int row, int col) {
    int temp;
    for (int i = 0; i < row; i++) {
        for (int j = 0; j < col/2; j++) {
            temp = mat[i][j];
            mat[i][j] = mat[i][col-j-1];
            mat[i][col-j-1] = temp;
        }
    }
}

void printMatrix(int mat[][3], int row, int col) {
    for (int i = 0; i < row; i++) {
        for (int j = 0; j < col; j++) {
            printf("%d ", mat[i][j]);
        }
        printf("\n");
    }
}

int main() {
    int mat[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

    printf("Original matrix:\n");
    printMatrix(mat, 3, 3);

    transpose(mat, 3, 3);
    printf("Transposed matrix:\n");
    printMatrix(mat, 3, 3);

    reverse(mat, 3, 3);
    printf("Reversed matrix:\n");
    printMatrix(mat, 3, 3);

    return 0;
}

输出结果为：

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

c语言矩阵的快速逆置

在C语言中，矩阵的快速逆置通常通过高斯-约旦消元法或LU分解等线性代数算法来实现。其中最常见的是利用LU分解（即低阶三角形矩阵乘上一个上阶三角形矩阵），这种方式可以有效地降低计算复杂度。

以下是使用LU分解对矩阵A求逆的一个简化版本：

#include <stdio.h>
#include <stdlib.h>

// 分解函数
void lu_decomposition(double a[ ][n], double l[ ][n], double u[ ][n]) {
    // 初始化L和U矩阵
    for (int i = 0; i < n; ++i) {
        l[i][i] = 1;
        for (int k = i + 1; k < n; ++k) {
            if (a[i][i] == 0) {
                printf("Error: Singular matrix\n");
                return;
            }
            l[i][k] = a[i][k] / a[i][i];
            for (int j = i; j < n; ++j) {
                a[k][j] -= l[k][i] * a[i][j];
            }
        }
        for (int k = i + 1; k < n; ++k) {
            double sum = 0;
            for (int j = i; j < n; ++j) {
                sum += l[k][j] * a[j][i];
            }
            u[k][i] = a[k][i] / sum;
            for (int j = i + 1; j < n; ++j) {
                a[k][j] -= u[k][i] * a[i][j];
            }
        }
    }
}

// 逆矩阵构造函数
void inverse(double a[ ][n], double inv_a[ ][n]) {
    int n = sizeof(a)/sizeof(a[0]);
    double l[n][n], u[n][n];
    lu_decomposition(a, l, u);

    // 使用反向填充的方式构建逆矩阵
    for (int i = n - 1; i >= 0; --i) {
        for (int j = 0; j <= i; ++j) {
            inv_a[i][j] = inv_a[i][j] / u[i][i]; // 取出L和U的倒数部分
            for (int k = 0; k < i; ++k) {
                inv_a[i][j] -= inv_a[k][j] * l[i][k];
            }
        }
    }
}

int main() {
    // 创建矩阵并进行逆置操作
    // ...（此处填写矩阵创建及初始化代码）
    inverse(matrix, inv_matrix);
    // ...（检查结果或打印）

    return 0;
}