C语言计算逆矩阵

花了4天写的，不过三天在重学线代。

#include<stdio.h>
#include<stdlib.h>    // 操作内存
#include<math.h>  // pow()函数,计算-1的n次方，可以不用这个函数，偷懒使用现成的

/*
    显示矩阵
    matrix: 矩阵
    order: 阶数
*/
void showMatrix(float** matrix, int order)
{
    for (int i = 0; i < order; i++) {
        for (int j = 0; j < order; j++) {
            printf("    %f    ", matrix[i][j]);
        }
        printf("|\n");
    }
}

/*
    交换两行
    一开始想使用初等行变换计算，此函数可以删除，用不到
    x1:调换第一行
    x2:调换第二行
    order:矩阵阶数
    matrix:矩阵
    */
void replaceRow(int x1, int x2, int order, float **matrix)
{    
    float temp;
    x1 -= 1;
    x2 -= 1;
    for (int i = 0; i < order; i++) {
        temp = matrix[x1][i];
        matrix[x1][i] = matrix[x2][i];
        matrix[x2][i] = temp;
    }
}

/*
    转置矩阵
    matrix: 矩阵
    order: 阶数
*/
void transposeMatrix(float** matrix, int order)
{
    float temp;
    for (int i = 0; i < order; i++) {
        for (int j = 0; j < i; j++) {
            temp = matrix[i][j];
            matrix[i][j] = matrix[j][i];
            matrix[j][i] = temp;
        }
    }
}

/*
    获取除了某行某列的矩阵
    oldmatrix: 原本矩阵
    newmatrix: 新矩阵
    row: 要删除行
    col: 要删除列
    order: 阶数
*/
void get(float** oldmatrix, float** newmatrix, int row, int col, int order)
{
    // 删除了一行一列，所以新矩阵行列均比原矩阵少1
    int a = 0, b = 0;
    int x, y, z = 0, w = 0;
    // i,j循环原矩阵
    for (int i = 0; i < order - 1; i++) {
        for (int j = 0; j < order - 1; j++) {
            // z,w代表行列的是否加一状态，防止多次加一，+1只需要1次
            if (i >= row && z == 0) { a += 1; z = 1; }
            if (j >= col && w == 0) { b += 1; w = 1; }
            
            newmatrix[i][j] = oldmatrix[i+a][j+b];
        }
        a = 0;b = 0;
        z = 0;w = 0;
    }
}

/*
    计算行列式
    matrix: 矩阵
    order: 阶数
*/
float calc(float** matrix, int order)
{
    // 递归求行列式值
    float num=0;
    int i, j;
    if (order == 2) {
        // 如果是二阶直接获取值
        num = matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
    }
    else {
        // 创建更小二维数组
        order -= 1;
        float** matrixlow = (float**)malloc(sizeof(float*) * order);
        for (i = 0; i < order; i++) {
            matrixlow[i] = (float*)malloc(sizeof(float) * order);
        }
        order += 1;
        
        // 循环展开第一行
        for (j = 0; j < order; j++) {

            get(matrix, matrixlow, 0, j, order);            
            // 此处开始递归，调用自身函数
            num += matrix[0][j] * pow(-1, j) * calc(matrixlow, order - 1);            
        }

        // 释放内存
        for (i = 0; i < order-1; ++i)free(*(matrixlow + i));
    }

    return num;
}


/*
    主函数
*/
int main()
{
    int order;    // 矩阵阶数
    int i, j;
    float det;

    // 获取矩阵阶
    printf("输入矩阵阶：");
    scanf("%d", &order);

    printf("输入的阶是：%d\n\n", order);    

    // 申请二维数组内存
    float** matrix = (float**)malloc(sizeof(float*) * order);
    for (i = 0; i < order; i++) {
        matrix[i] = (float*)malloc(sizeof(float) * order);
    }

    // 获取输入
    for (i = 0; i < order; i++) {
        for (j = 0; j < order; j++) {
            printf("位置：( %d , %d)请输入数据：",i + 1,j + 1);            
            scanf("%f", &matrix[i][j]);
        }
    }    
        
    // 计算并显示det    
    det = calc(matrix, order);
    printf("\ndet值为：%f",det);
    // 0不能做除数
    if (det == 0) 
        printf("\n矩阵接近奇异值，结果可能不准确！");
    printf("\n\n");

    // 显示输入矩阵
    printf("\n输入的矩阵是：\n\n");
    showMatrix(matrix, order);    

    // 申请二维数组存储结果
    float** Rmatrix = (float**)malloc(sizeof(float*) * order);
    for (i = 0; i < order; i++) {
        Rmatrix[i] = (float*)malloc(sizeof(float) * order);
    }    

    
    // 开始计算
    if (order == 2) {
        // 阶数为二直接运行公式
        float n = 1 / (matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0]);
        Rmatrix[0][0] = n * matrix[1][1];
        Rmatrix[0][1] = -n * matrix[0][1];
        Rmatrix[1][0] = -n * matrix[1][0];
        Rmatrix[1][1] = n * matrix[0][0];        
    }
    else {
        // 转置矩阵并显示
        transposeMatrix(matrix, order);
        printf("\n\n转置后为:\n\n");
        showMatrix(matrix, order);
        
        // 循环求i，j位的代数余子式
        for (i = 0; i < order; i++) {
            for (j = 0; j < order; j++) {
                // 申请二维数组
                order -= 1;
                float** matrixlow = (float**)malloc(sizeof(float*) * order);
                for (int t = 0; t < order; t++) {
                    matrixlow[t] = (float*)malloc(sizeof(float) * order);
                }
                order += 1;                

                // 获取除了i，j行的值组成行列式
                get(matrix, matrixlow, i, j, order);                            
                // 计算行列式值除以det
                Rmatrix[i][j] = pow(-1, i + j) * calc(matrixlow, order - 1) / det;                

                // 释放内存
                for (int t = 0; t < order-1; ++t)free(*(matrixlow + t));                
            }
        }        

    }
    
    // 显示逆矩阵
    printf("\n\n逆矩阵为：\n\n");
    showMatrix(Rmatrix, order);


    //// 释放二维数组
    for (i = 0; i < order; ++i)free(*(matrix + i));    
    for (i = 0; i < order; ++i)free(*(Rmatrix + i));

    return 0;
}