c语言利用指针和动态分配内存求逆矩阵

要求逆矩阵，必须先保证矩阵可逆。对于一个 n×n 的矩阵 A，若其行列式 |A| 不等于 0，则 A 可逆。这也就意味着 A 的行向量和列向量线性无关。接下来，我们可以使用高斯-约旦消元法求 A 的逆矩阵。

具体实现中，我们可以使用数组存储矩阵 A 和其逆矩阵 B，同时利用指针动态分配内存空间。主要的步骤如下：

1. 首先，我们要将 A 中的每行数据复制到 B 中对角线上。

2. 然后，对于每一列，我们可以先将左下角数据归一化，然后逐行消元，然后递归逆矩阵。

3. 最后，我们就可以得到矩阵 A 的逆矩阵 B。

以下是代码实现示例：

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

#define N 4

void print_matrix(float **matrix, int n) {
    for(int i=0; i<n; i++) {
        for(int j=0; j<n; j++) {
            printf("%f\t", matrix[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

void inverse_matrix(float **A, float **B, int n) {
    float tmp;
    for(int i=0; i<n; i++) {
        for(int j=0; j<n; j++) {
            B[i][j] = 0;
            if(i==j) {
                B[i][j] = 1;
            }
        }
    }

    for(int i=0; i<n; i++) {
        tmp = A[i][i];
        for(int j=0; j<n; j++) {
            A[i][j] /= tmp;
            B[i][j] /= tmp;
        }
        for(int j=0; j<n; j++) {
            if(j!=i) {
                tmp = A[j][i];
                for(int k=0; k<n; k++) {
                    A[j][k] -= tmp * A[i][k];
                    B[j][k] -= tmp * B[i][k];
                }
            }
        }
    }
}

int main() {
    float **A = (float **)malloc(sizeof(float *) * N);
    for(int i=0; i<N; i++) {
        A[i] = (float *)malloc(sizeof(float) * N);
    }
    A[0][0] = 1; A[0][1] = 0; A[0][2] = 2; A[0][3] = -1;
    A[1][0] = 3; A[1][1] = 0; A[1][2] = 0; A[1][3] = 5;
    A[2][0] = 2; A[2][1] = 1; A[2][2] = 4; A[2][3] = -3;
    A[3][0] = 1; A[3][1] = 0; A[3][2] = 5; A[3][3] = 0;
    float **B = (float **)malloc(sizeof(float *) * N);
    for(int i=0; i<N; i++) {
        B[i] = (float *)malloc(sizeof(float) * N);
    }
    print_matrix(A, N);
    inverse_matrix(A, B, N);
    print_matrix(B, N);
    return 0;
}

以上代码仅供参考，实际应用需要根据具体情况进行调整。