在C语言中计算矩阵行列式是否有其他方法？能否用for循环实现？

阿华AIGC实验室

2026-5-7

用For循环实现通用矩阵行列式计算

你说得对，硬编码3阶行列式的写法确实不够灵活，只能处理固定大小的矩阵，而且代码可读性差。当然可以用for循环来实现通用的行列式计算，甚至能支持任意n阶方阵（只要内存能容纳）。下面我给你两种常见的实现思路，都用到了循环：

方法一：按行展开（递归+循环）

行列式的数学定义本身就是递归的——n阶行列式可以展开为第一行每个元素乘以它的代数余子式之和。我们可以用循环遍历第一行的每个元素，递归计算对应余子式的行列式，再累加结果。

代码示例

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

// 创建余子式矩阵：跳过指定行和列生成新矩阵
void createMinorMatrix(int **matrix, int **minor, int n, int excludeRow, int excludeCol) {
    int rowIdx = 0, colIdx = 0;
    for (int i = 0; i < n; i++) {
        if (i == excludeRow) continue;
        colIdx = 0;
        for (int j = 0; j < n; j++) {
            if (j == excludeCol) continue;
            minor[rowIdx][colIdx] = matrix[i][j];
            colIdx++;
        }
        rowIdx++;
    }
}

// 递归+循环计算行列式
long calculateDeterminant(int **matrix, int n) {
    // 终止条件：1阶和2阶矩阵直接计算
    if (n == 1) return matrix[0][0];
    if (n == 2) return (long)matrix[0][0]*matrix[1][1] - (long)matrix[0][1]*matrix[1][0];
    
    long det = 0;
    int sign = 1;
    // 循环遍历第一行的每个元素，计算代数余子式之和
    for (int col = 0; col < n; col++) {
        // 动态分配余子式矩阵内存
        int **minor = (int **)malloc((n-1)*sizeof(int *));
        for (int i = 0; i < n-1; i++) {
            minor[i] = (int *)malloc((n-1)*sizeof(int));
        }
        createMinorMatrix(matrix, minor, n, 0, col);
        det += sign * matrix[0][col] * calculateDeterminant(minor, n-1);
        sign = -sign; // 交替符号
        // 释放余子式内存，避免泄漏
        for (int i = 0; i < n-1; i++) {
            free(minor[i]);
        }
        free(minor);
    }
    return det;
}

int main() {
    int n;
    printf("Enter the order of the matrix: ");
    scanf("%d", &n);
    
    // 动态分配矩阵内存，支持任意阶数
    int **matrix = (int **)malloc(n*sizeof(int *));
    for (int i = 0; i < n; i++) {
        matrix[i] = (int *)malloc(n*sizeof(int));
    }
    
    printf("Enter the %d elements of the matrix:\n", n*n);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            scanf("%d", &matrix[i][j]);
        }
    }
    
    printf("\nThe matrix is:\n");
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            printf("%d\t", matrix[i][j]);
        }
        printf("\n");
    }
    
    long determinant = calculateDeterminant(matrix, n);
    printf("\nDeterminant of the %dx%d matrix: %ld\n", n, n, determinant);
    
    // 释放矩阵内存
    for (int i = 0; i < n; i++) {
        free(matrix[i]);
    }
    free(matrix);
    
    return 0;
}

代码说明

createMinorMatrix用两层循环跳过指定的行和列，生成对应元素的余子式矩阵；
calculateDeterminant里的for循环遍历第一行所有元素，递归计算余子式的行列式，同时处理代数余子式的交替符号；
动态内存分配让代码摆脱了固定阶数的限制，能处理任意大小的方阵。

方法二：高斯消元法（纯循环实现，非递归）

如果不想用递归，高斯消元法是更高效的选择——通过行变换把矩阵转化为上三角矩阵，上三角矩阵的行列式就是对角线元素的乘积。整个过程可以用纯循环实现，效率比递归高很多（尤其适合高阶矩阵）。

代码示例

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

// 高斯消元法计算行列式
long calculateDeterminant(int **matrix, int n) {
    long det = 1;
    int sign = 1;
    
    for (int i = 0; i < n; i++) {
        // 找主元：当前列绝对值最大的行，避免除零和精度误差
        int pivotRow = i;
        for (int j = i+1; j < n; j++) {
            if (abs(matrix[j][i]) > abs(matrix[pivotRow][i])) {
                pivotRow = j;
            }
        }
        
        // 主元为0，行列式直接为0
        if (matrix[pivotRow][i] == 0) {
            return 0;
        }
        
        // 交换行则符号翻转
        if (pivotRow != i) {
            int *temp = matrix[i];
            matrix[i] = matrix[pivotRow];
            matrix[pivotRow] = temp;
            sign = -sign;
        }
        
        // 消去当前列下方的所有元素
        for (int j = i+1; j < n; j++) {
            long factor = (long)matrix[j][i] / matrix[i][i];
            for (int k = i; k < n; k++) {
                matrix[j][k] -= factor * matrix[i][k];
            }
        }
        
        det *= matrix[i][i];
    }
    
    return det * sign;
}

int main() {
    int n;
    printf("Enter the order of the matrix: ");
    scanf("%d", &n);
    
    int **matrix = (int **)malloc(n*sizeof(int *));
    for (int i = 0; i < n; i++) {
        matrix[i] = (int *)malloc(n*sizeof(int));
    }
    
    printf("Enter the %d elements of the matrix:\n", n*n);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            scanf("%d", &matrix[i][j]);
        }
    }
    
    printf("\nThe matrix is:\n");
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            printf("%d\t", matrix[i][j]);
        }
        printf("\n");
    }
    
    // 注意：高斯消元会修改原矩阵，若需保留原矩阵，需先复制一份
    long determinant = calculateDeterminant(matrix, n);
    printf("\nDeterminant of the %dx%d matrix: %ld\n", n, n, determinant);
    
    // 释放内存
    for (int i = 0; i < n; i++) {
        free(matrix[i]);
    }
    free(matrix);
    
    return 0;
}