Berechnung der Determinante einer Matrix in C

CCBeginner
Jetzt üben

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

In diesem Lab erfahren Sie, wie Sie die Determinante einer quadratischen Matrix in der Programmiersprache C berechnen können. Das Lab umfasst die folgenden Schritte: Einlesen der Dimension und der Elemente der Matrix, Berechnung der Determinante mit einer rekursiven Methode oder der LU-Zerlegung (LU decomposition) und Ausgabe des Endergebnisses. Die schrittweisen Anweisungen führen Sie durch den Prozess der Erstellung eines Programms, das quadratische Matrizen bis zu einer Größe von 10x10 verarbeiten kann. Sie können die Matrixelemente dynamisch eingeben und die berechnete Determinante anzeigen lassen.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL c(("C")) -.-> c/ControlFlowGroup(["Control Flow"]) c(("C")) -.-> c/CompoundTypesGroup(["Compound Types"]) c(("C")) -.-> c/FunctionsGroup(["Functions"]) c(("C")) -.-> c/UserInteractionGroup(["User Interaction"]) c/ControlFlowGroup -.-> c/for_loop("For Loop") c/CompoundTypesGroup -.-> c/arrays("Arrays") c/FunctionsGroup -.-> c/recursion("Recursion") c/UserInteractionGroup -.-> c/user_input("User Input") c/UserInteractionGroup -.-> c/output("Output") subgraph Lab Skills c/for_loop -.-> lab-435157{{"Berechnung der Determinante einer Matrix in C"}} c/arrays -.-> lab-435157{{"Berechnung der Determinante einer Matrix in C"}} c/recursion -.-> lab-435157{{"Berechnung der Determinante einer Matrix in C"}} c/user_input -.-> lab-435157{{"Berechnung der Determinante einer Matrix in C"}} c/output -.-> lab-435157{{"Berechnung der Determinante einer Matrix in C"}} end

Einlesen der Dimension und der Elemente (Quadratische Matrix)

In diesem Schritt erfahren Sie, wie Sie in der Programmiersprache C die Dimension und die Elemente einer quadratischen Matrix einlesen können. Wir werden ein Programm erstellen, das es Benutzern ermöglicht, die Größe der Matrix und ihre Elemente dynamisch einzugeben.

Zunächst erstellen wir eine neue C-Datei für unser Programm zur Berechnung der Determinante einer Matrix:

cd ~/project
nano matrix_determinant.c

Fügen Sie nun den folgenden Code hinzu, um die Dimension und die Elemente der Matrix einzulesen:

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

#define MAX_SIZE 10

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

    // Einlesen der Matrixdimension
    printf("Geben Sie die Größe der quadratischen Matrix (1-%d) ein: ", MAX_SIZE);
    scanf("%d", &n);

    // Überprüfung der Matrixgröße
    if (n < 1 || n > MAX_SIZE) {
        printf("Ungültige Matrixgröße. Bitte geben Sie eine Größe zwischen 1 und %d ein.\n", MAX_SIZE);
        return 1;
    }

    // Einlesen der Matrixelemente
    printf("Geben Sie die Matrixelemente ein:\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("Geben Sie das Element [%d][%d] ein: ", i, j);
            scanf("%d", &matrix[i][j]);
        }
    }

    // Ausgabe der Matrix zur Überprüfung der Eingabe
    printf("\nEingegebene Matrix:\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }

    return 0;
}

Kompilieren und starten Sie das Programm:

gcc matrix_determinant.c -o matrix_determinant
./matrix_determinant

Beispielausgabe:

Geben Sie die Größe der quadratischen Matrix (1-10) ein: 3
Geben Sie die Matrixelemente ein:
Geben Sie das Element [0][0] ein: 1
Geben Sie das Element [0][1] ein: 2
Geben Sie das Element [0][2] ein: 3
Geben Sie das Element [1][0] ein: 4
Geben Sie das Element [1][1] ein: 5
Geben Sie das Element [1][2] ein: 6
Geben Sie das Element [2][0] ein: 7
Geben Sie das Element [2][1] ein: 8
Geben Sie das Element [2][2] ein: 9

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

Lassen Sie uns den Code analysieren:

  • Wir definieren eine maximale Matrixgröße von 10, um eine übermäßige Speicherbelegung zu vermeiden.
  • Das Programm fordert zunächst den Benutzer auf, die Matrixgröße einzugeben.
  • Es überprüft die Eingabe, um sicherzustellen, dass sie im zulässigen Bereich liegt.
  • Anschließend fordert es den Benutzer auf, jedes Matrixelement einzeln einzugeben.
  • Schließlich gibt es die eingegebene Matrix aus, um die Eingabe zu überprüfen.

Verwenden einer rekursiven Methode oder der LU-Zerlegung (LU decomposition)

In diesem Schritt implementieren wir eine rekursive Methode zur Berechnung der Determinante einer Matrix. Wir werden das vorherige Programm erweitern, um eine Funktion zur Berechnung der Determinante hinzuzufügen.

Bearbeiten Sie die Datei matrix_determinant.c:

nano matrix_determinant.c

Ersetzen Sie den vorherigen Inhalt durch den folgenden Code:

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

#define MAX_SIZE 10

// Funktion zur rekursiven Berechnung der Determinante
int determinant(int matrix[MAX_SIZE][MAX_SIZE], int n) {
    int det = 0;
    int submatrix[MAX_SIZE][MAX_SIZE];

    // Basisfall für 1x1-Matrizen
    if (n == 1) {
        return matrix[0][0];
    }

    // Basisfall für 2x2-Matrizen
    if (n == 2) {
        return matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
    }

    // Rekursiver Fall für größere Matrizen
    int sign = 1;
    for (int k = 0; k < n; k++) {
        // Erstellen der Untermatrix
        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++;
        }

        // Rekursive Berechnung
        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];

    // Einlesen der Matrixdimension
    printf("Geben Sie die Größe der quadratischen Matrix (1-%d) ein: ", MAX_SIZE);
    scanf("%d", &n);

    // Überprüfung der Matrixgröße
    if (n < 1 || n > MAX_SIZE) {
        printf("Ungültige Matrixgröße. Bitte geben Sie eine Größe zwischen 1 und %d ein.\n", MAX_SIZE);
        return 1;
    }

    // Einlesen der Matrixelemente
    printf("Geben Sie die Matrixelemente ein:\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("Geben Sie das Element [%d][%d] ein: ", i, j);
            scanf("%d", &matrix[i][j]);
        }
    }

    // Berechnung und Ausgabe der Determinante
    int det = determinant(matrix, n);
    printf("\nDeterminante der Matrix: %d\n", det);

    return 0;
}

Kompilieren und starten Sie das Programm:

gcc matrix_determinant.c -o matrix_determinant
./matrix_determinant

Beispielausgabe:

Geben Sie die Größe der quadratischen Matrix (1-10) ein: 3
Geben Sie die Matrixelemente ein:
Geben Sie das Element [0][0] ein: 1
Geben Sie das Element [0][1] ein: 2
Geben Sie das Element [0][2] ein: 3
Geben Sie das Element [1][0] ein: 4
Geben Sie das Element [1][1] ein: 5
Geben Sie das Element [1][2] ein: 6
Geben Sie das Element [2][0] ein: 7
Geben Sie das Element [2][1] ein: 8
Geben Sie das Element [2][2] ein: 9

Determinante der Matrix: 0

Wichtige Punkte zur rekursiven Berechnung der Determinante:

  • Die Funktion determinant() verwendet einen rekursiven Ansatz zur Berechnung der Determinante einer Matrix.
  • Für 1x1- und 2x2-Matrizen haben wir Basisfälle mit direkten Berechnungen.
  • Für größere Matrizen verwenden wir die Methode der Kofaktorexpansion entlang der ersten Zeile.
  • Die Funktion erstellt Untermatrizen und berechnet deren Determinanten rekursiv.

Ausgabe der Determinante

In diesem letzten Schritt verbessern wir unser Programm zur Berechnung der Determinante einer Matrix, indem wir detailliertere Ausgaben hinzufügen und die Fehlerbehandlung verbessern, um die Benutzererfahrung zu steigern.

Bearbeiten Sie die Datei matrix_determinant.c:

nano matrix_determinant.c

Ersetzen Sie den vorherigen Inhalt durch den folgenden verbesserten Code:

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

#define MAX_SIZE 10

// Funktion zur rekursiven Berechnung der Determinante
int determinant(int matrix[MAX_SIZE][MAX_SIZE], int n) {
    int det = 0;
    int submatrix[MAX_SIZE][MAX_SIZE];

    // Basisfall für 1x1-Matrizen
    if (n == 1) {
        return matrix[0][0];
    }

    // Basisfall für 2x2-Matrizen
    if (n == 2) {
        return matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
    }

    // Rekursiver Fall für größere Matrizen
    int sign = 1;
    for (int k = 0; k < n; k++) {
        // Erstellen der Untermatrix
        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++;
        }

        // Rekursive Berechnung
        det += sign * matrix[0][k] * determinant(submatrix, n - 1);
        sign = -sign;
    }

    return det;
}

// Funktion zur formatierten Ausgabe der Matrix
void print_matrix(int matrix[MAX_SIZE][MAX_SIZE], int n) {
    printf("\nMatrix:\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) {
        // Einlesen der Matrixdimension
        printf("Geben Sie die Größe der quadratischen Matrix (1-%d) ein: ", MAX_SIZE);
        if (scanf("%d", &n)!= 1) {
            printf("Ungültige Eingabe. Bitte geben Sie eine Zahl ein.\n");
            while (getchar()!= '\n'); // Eingabepuffer leeren
            continue;
        }

        // Überprüfung der Matrixgröße
        if (n < 1 || n > MAX_SIZE) {
            printf("Ungültige Matrixgröße. Bitte geben Sie eine Größe zwischen 1 und %d ein.\n", MAX_SIZE);
            continue;
        }

        valid_input = true;
    }

    // Einlesen der Matrixelemente
    printf("Geben Sie die Matrixelemente ein:\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("Geben Sie das Element [%d][%d] ein: ", i, j);
            while (scanf("%d", &matrix[i][j])!= 1) {
                printf("Ungültige Eingabe. Bitte geben Sie eine Ganzzahl für das Element [%d][%d] ein: ", i, j);
                while (getchar()!= '\n'); // Eingabepuffer leeren
            }
        }
    }

    // Ausgabe der eingegebenen Matrix
    print_matrix(matrix, n);

    // Berechnung und Ausgabe der Determinante
    int det = determinant(matrix, n);

    // Formatierte Ausgabe der Determinante
    printf("\n--- Determinantenberechnung ---\n");
    printf("Matrixgröße: %d x %d\n", n, n);
    printf("Determinante: %d\n", det);

    return 0;
}

Kompilieren und starten Sie das Programm:

gcc matrix_determinant.c -o matrix_determinant
./matrix_determinant

Beispielausgabe:

Geben Sie die Größe der quadratischen Matrix (1-10) ein: 3
Geben Sie die Matrixelemente ein:
Geben Sie das Element [0][0] ein: 1
Geben Sie das Element [0][1] ein: 2
Geben Sie das Element [0][2] ein: 3
Geben Sie das Element [1][0] ein: 4
Geben Sie das Element [1][1] ein: 5
Geben Sie das Element [1][2] ein: 6
Geben Sie das Element [2][0] ein: 7
Geben Sie das Element [2][1] ein: 8
Geben Sie das Element [2][2] ein: 9

Matrix:
    1     2     3
    4     5     6
    7     8     9

--- Determinantenberechnung ---
Matrixgröße: 3 x 3
Determinante: 0

Wichtige Verbesserungen:

  • Eingabevalidierung hinzugefügt, um ungültige Eingaben zu behandeln
  • Eine separate Funktion zur formatierten Ausgabe der Matrix erstellt
  • Ausgabe verbessert, um die Matrixgröße und die Determinante klar anzuzeigen
  • Fehlerbehandlung für Benutzereingaben verbessert

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie in der Programmiersprache C die Dimension und die Elemente einer quadratischen Matrix einlesen können. Sie haben ein Programm erstellt, das es Benutzern ermöglicht, die Größe der Matrix und ihre Elemente dynamisch einzugeben. Das Programm überprüft die Matrixgröße und fordert dann den Benutzer auf, die Matrixelemente einzugeben. Schließlich gibt es die eingegebene Matrix aus, um die Eingabe zu überprüfen.

In den nächsten Schritten dieses Labs erfahren Sie, wie Sie eine rekursive Methode oder die LU-Zerlegung (LU decomposition) verwenden können, um die Determinante der eingegebenen Matrix zu berechnen, und wie Sie die Determinante ausgeben können.