LabEx
登录免费加入

用 C 语言计算矩阵的行列式

CBeginner
立即练习

简介

在本实验中，你将学习如何在 C 编程中计算方阵的行列式。本实验涵盖以下步骤：读取矩阵的维度和元素，使用递归或 LU 分解方法计算行列式，并打印最终结果。逐步说明将指导你完成创建一个程序的过程，该程序可以处理最大为 10x10 大小的方阵，允许你动态输入矩阵元素并显示计算出的行列式。

读取维度和元素（方阵）

在这一步中，你将学习如何在 C 编程中读取方阵的维度和元素。我们将创建一个程序，允许用户动态输入矩阵的大小及其元素。

首先，为我们的矩阵行列式程序创建一个新的 C 文件：

cd ~/project
nano matrix_determinant.c

现在，添加以下代码来读取矩阵维度和元素：

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

#define MAX_SIZE 10

int main() {
    int n, i, j;
    int matrix[MAX_SIZE][MAX_SIZE];

    // 读取矩阵维度
    printf("Enter the size of the square matrix (1-%d): ", MAX_SIZE);
    scanf("%d", &n);

    // 验证矩阵大小
    if (n < 1 || n > MAX_SIZE) {
        printf("Invalid matrix size. Please enter a size between 1 and %d.\n", MAX_SIZE);
        return 1;
    }

    // 读取矩阵元素
    printf("Enter the matrix elements:\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("Enter element [%d][%d]: ", i, j);
            scanf("%d", &matrix[i][j]);
        }
    }

    // 打印矩阵以验证输入
    printf("\nEntered Matrix:\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }

    return 0;
}

编译并运行程序：

gcc matrix_determinant.c -o matrix_determinant
./matrix_determinant

示例输出：

Enter the size of the square matrix (1-10): 3
Enter the matrix elements:
Enter element [0][0]: 1
Enter element [0][1]: 2
Enter element [0][2]: 3
Enter element [1][0]: 4
Enter element [1][1]: 5
Enter element [1][2]: 6
Enter element [2][0]: 7
Enter element [2][1]: 8
Enter element [2][2]: 9

Entered Matrix:
1 2 3
4 5 6
7 8 9

让我们来分析一下这段代码：

  • 我们定义了最大矩阵大小为 10，以防止过度分配内存。
  • 程序首先要求用户输入矩阵大小。
  • 它会验证输入，确保其在允许的范围内。
  • 然后，它提示用户逐个输入每个矩阵元素。
  • 最后，它打印输入的矩阵以验证输入。

使用递归或 LU 分解方法

在这一步中，我们将实现一种递归方法来计算矩阵的行列式。我们将修改之前的程序，加入一个行列式计算函数。

更新 matrix_determinant.c 文件：

nano matrix_determinant.c

将之前的内容替换为以下代码：

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

#define MAX_SIZE 10

// 递归计算行列式的函数
int determinant(int matrix[MAX_SIZE][MAX_SIZE], int n) {
    int det = 0;
    int submatrix[MAX_SIZE][MAX_SIZE];

    // 1x1 矩阵的基例
    if (n == 1) {
        return matrix[0][0];
    }

    // 2x2 矩阵的基例
    if (n == 2) {
        return matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
    }

    // 更大矩阵的递归情况
    int sign = 1;
    for (int k = 0; k < n; k++) {
        // 创建子矩阵
        int subi = 0;
        for (int i = 1; i < n; i++) {
            int subj = 0;
            for (int j = 0; j < n; j++) {
                if (j == k) continue;
                submatrix[subi][subj] = matrix[i][j];
                subj++;
            }
            subi++;
        }

        // 递归计算
        det += sign * matrix[0][k] * determinant(submatrix, n - 1);
        sign = -sign;
    }

    return det;
}

int main() {
    int n, i, j;
    int matrix[MAX_SIZE][MAX_SIZE];

    // 读取矩阵维度
    printf("Enter the size of the square matrix (1-%d): ", MAX_SIZE);
    scanf("%d", &n);

    // 验证矩阵大小
    if (n < 1 || n > MAX_SIZE) {
        printf("Invalid matrix size. Please enter a size between 1 and %d.\n", MAX_SIZE);
        return 1;
    }

    // 读取矩阵元素
    printf("Enter the matrix elements:\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("Enter element [%d][%d]: ", i, j);
            scanf("%d", &matrix[i][j]);
        }
    }

    // 计算并打印行列式
    int det = determinant(matrix, n);
    printf("\nDeterminant of the matrix: %d\n", det);

    return 0;
}

编译并运行程序：

gcc matrix_determinant.c -o matrix_determinant
./matrix_determinant

示例输出：

Enter the size of the square matrix (1-10): 3
Enter the matrix elements:
Enter element [0][0]: 1
Enter element [0][1]: 2
Enter element [0][2]: 3
Enter element [1][0]: 4
Enter element [1][1]: 5
Enter element [1][2]: 6
Enter element [2][0]: 7
Enter element [2][1]: 8
Enter element [2][2]: 9

Determinant of the matrix: 0

关于递归行列式计算的要点：

  • determinant() 函数使用递归方法来计算矩阵的行列式。
  • 对于 1x1 和 2x2 矩阵，我们有直接计算的基例。
  • 对于更大的矩阵，我们使用沿第一行的余子式展开方法。
  • 该函数创建子矩阵并递归计算它们的行列式。

打印行列式

在这最后一步中，我们将通过添加更详细的输出和错误处理来增强我们的矩阵行列式程序，以改善用户体验。

更新 matrix_determinant.c 文件：

nano matrix_determinant.c

将之前的内容替换为以下改进后的代码：

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

#define MAX_SIZE 10

// 递归计算行列式的函数
int determinant(int matrix[MAX_SIZE][MAX_SIZE], int n) {
    int det = 0;
    int submatrix[MAX_SIZE][MAX_SIZE];

    // 1x1 矩阵的基例
    if (n == 1) {
        return matrix[0][0];
    }

    // 2x2 矩阵的基例
    if (n == 2) {
        return matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
    }

    // 更大矩阵的递归情况
    int sign = 1;
    for (int k = 0; k < n; k++) {
        // 创建子矩阵
        int subi = 0;
        for (int i = 1; i < n; i++) {
            int subj = 0;
            for (int j = 0; j < n; j++) {
                if (j == k) continue;
                submatrix[subi][subj] = matrix[i][j];
                subj++;
            }
            subi++;
        }

        // 递归计算
        det += sign * matrix[0][k] * determinant(submatrix, n - 1);
        sign = -sign;
    }

    return det;
}

// 以格式化方式打印矩阵的函数
void print_matrix(int matrix[MAX_SIZE][MAX_SIZE], int n) {
    printf("\n矩阵:\n");
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            printf("%5d ", matrix[i][j]);
        }
        printf("\n");
    }
}

int main() {
    int n, i, j;
    int matrix[MAX_SIZE][MAX_SIZE];
    bool valid_input = false;

    while (!valid_input) {
        // 读取矩阵维度
        printf("输入方阵的大小 (1-%d): ", MAX_SIZE);
        if (scanf("%d", &n)!= 1) {
            printf("输入无效。请输入一个数字。\n");
            while (getchar()!= '\n'); // 清除输入缓冲区
            continue;
        }

        // 验证矩阵大小
        if (n < 1 || n > MAX_SIZE) {
            printf("矩阵大小无效。请输入 1 到%d之间的大小。\n", MAX_SIZE);
            continue;
        }

        valid_input = true;
    }

    // 读取矩阵元素
    printf("输入矩阵元素:\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("输入元素 [%d][%d]: ", i, j);
            while (scanf("%d", &matrix[i][j])!= 1) {
                printf("输入无效。请为元素 [%d][%d] 输入一个整数：", i, j);
                while (getchar()!= '\n'); // 清除输入缓冲区
            }
        }
    }

    // 打印输入的矩阵
    print_matrix(matrix, n);

    // 计算并打印行列式
    int det = determinant(matrix, n);

    // 格式化的行列式输出
    printf("\n--- 行列式计算 ---\n");
    printf("矩阵维度：%d x %d\n", n, n);
    printf("行列式：%d\n", det);

    return 0;
}

编译并运行程序：

gcc matrix_determinant.c -o matrix_determinant
./matrix_determinant

示例输出：

输入方阵的大小(1-10): 3
输入矩阵元素:
输入元素 [0][0]: 1
输入元素 [0][1]: 2
输入元素 [0][2]: 3
输入元素 [1][0]: 4
输入元素 [1][1]: 5
输入元素 [1][2]: 6
输入元素 [2][0]: 7
输入元素 [2][1]: 8
输入元素 [2][2]: 9

矩阵:
    1     2     3
    4     5     6
    7     8     9

--- 行列式计算 ---
矩阵维度: 3 x 3
行列式: 0

主要改进点：

  • 添加了输入验证以处理无效输入
  • 创建了一个单独的函数来以更好的格式打印矩阵
  • 增强了输出以清晰显示矩阵维度和行列式
  • 改进了对用户输入的错误处理

总结

在本实验中，你学习了如何在 C 编程中读取方阵的维度和元素。你创建了一个程序，允许用户动态输入矩阵的大小及其元素。该程序会验证矩阵大小，然后提示用户输入矩阵元素。最后，它会打印输入的矩阵以验证输入。

本实验的后续步骤将涵盖如何使用递归或 LU 分解方法来计算输入矩阵的行列式，以及如何打印行列式。

相关 C 课程
C 语言编程入门

C 语言编程入门

c
使用 C 语言构建 Flappy Bird

使用 C 语言构建 Flappy Bird

c
使用 C 语言制作简易计算器

使用 C 语言制作简易计算器

c