C++ 程序矩阵行列式

矩阵行列式是什么？

矩阵行列式是一个特殊的数字，仅针对方阵（行和列一样多的矩阵）定义。行列式在微积分和其他涉及代数的矩阵中使用，实际上它以一个实数代表矩阵，可用于解线性方程组并找到矩阵的逆。

如何计算行列式？

矩阵行列式的值可以通过以下过程计算：

对于第一行或第一列的每个元素，取那些元素的余子式，然后将该元素乘以相应余子式的行列式，并用交替符号将它们相加。作为基本情况，1*1矩阵的行列式值为单个值本身。

一个元素的余子式 是一个矩阵，我们可以通过从该矩阵中删除该元素的行和列来获得。

2 x 2矩阵的行列式：

C++ 程序矩阵行列式

3 x 3矩阵的行列式：

C++ 程序矩阵行列式

// C++程序，用于查找矩阵的行列式
#include <iostream>
using namespace std;
 
// 输入矩阵的维度
#define N 4
 
// 函数用于在temp[][]中获取mat[p][q]的代数余子式。n是mat[][]当前的维度
void getCofactor(int mat[N][N],
                 int temp[N][N], int p,
                 int q, int n)
{
    int i = 0, j = 0;
 
    // 循环遍历矩阵中的每个元素
    for (int row = 0; row < n; row++)
    {
        for (int col = 0; col < n; col++)
        {
            // 只复制不在给定行和列的元素到临时矩阵中
            if (row != p && col != q)
            {
                temp[i][j++] = mat[row][col];
 
                // 行已满，因此增加行索引并重新设置列索引
                if (j == n - 1)
                {
                    j = 0;
                    i++;
                }
            }
        }
    }
}
 
/* 递归函数，用于查找矩阵的行列式。
   n是mat[][]的当前维度。*/
int determinantOfMatrix(int mat[N][N], int n)
{
    // 初始化结果
    int D = 0;
 
    // 基本情况：如果矩阵只包含一个元素
    if (n == 1)
        return mat[0][0];
 
    // 存储代数余子式
    int temp[N][N];
 
    // 存储符号乘数
    int sign = 1;
 
    // 循环遍历第一行的每个元素
    for (int f = 0; f < n; f++)
    {
        // 获取mat[0][f]的代数余子式
        getCofactor(mat, temp, 0, f, n);
        D += sign * mat[0][f] *
             determinantOfMatrix(temp, n - 1);
 
        // 这些项需要交替带符号相加
        sign = -sign;
    }
 
    return D;
}
 
// 函数用于显示矩阵
void display(int mat[N][N],
             int row, int col)
{
    for (int i = 0; i < row; i++)
    {
        for (int j = 0; j < col; j++)
            cout << "  " <<  mat[i][j];
        cout << "n";
    }
}
 
// 主函数
int main()
{
    int mat[N][N] = {{1, 0, 2, -1},
                     {3, 0, 0, 5},
                     {2, 1, 4, -3},
                     {1, 0, 5, 0}};
 
    // 调用函数
    cout << "矩阵的行列式为：" <<
             determinantOfMatrix(mat, N);
    return 0;
}
 
// 由shivanisinghss2110贡献```

输出

矩阵的行列式为：30

时间复杂度： O(n!)。

说明： getCofactor（）函数的时间复杂度为O（N ^ 2），因为它需要循环遍历N x N矩阵的所有元素。determinantOfMatrix（）函数的时间复杂度可以使用以下递归关系计算：

T（N）= N * T（N-1）+ O（N ^ 3）

第一个项N * T（N-1）表示计算（N-1）x（N-1）子矩阵行列式所需的时间，第二个项O（N ^ 3）表示计算原始矩阵第一行中每个元素的代数余子式所需的时间。使用析因展开，我们可以将一个NxN矩阵的行列式计算为每个（N-1）x（N-1）矩阵的行列式之和，每个矩阵计算代数余子式需要O（N ^ 2）的时间。因此，determinantOfMatrix（）函数的时间复杂度为O（N！），这是最坏情况下的情况，其中矩阵是置换矩阵。

display（）函数的时间复杂度为O（N ^ 2），因为它循环遍历矩阵的所有元素以打印它们。程序的整体时间复杂度由determinantOfMatrix（）函数主导，因此程序的时间复杂度为O（N！）。

空间复杂度： O（n * n），因为创建了temp矩阵。

矩阵的伴随和逆

行列式具有各种有用的特性，可以用于解决与矩阵相关的问题，

本文由Utkarsh Trivedi撰写。如果您发现任何错误或想分享更多有关上述主题的信息，请在评论中写下。

上述方法中讨论了递归方法。 当矩阵的大小较大时，它消耗更多的堆栈大小。

在这种方法中，我们使用行列式的特性。在这种方法中，我们将给定的矩阵转换为上三角矩阵，使用行列式的特性。上三角矩阵的行列式是对角线上所有元素的乘积。有关行列式的特性，请参阅此网站：https://cran.r-project.org/web/packages/matlib/vignettes/det-ex1.html

在这种方法中，我们迭代每个对角线元素，并使用行列式的特性将对角线以下的所有元素都变为零。

如果对角线元素为零，则在同一列中搜索下一个非零元素。

有两种情况

情况1：

如果没有非零元素。在这种情况下，矩阵的行列式为零。

情况2：

如果存在非零元素，则存在两种情况

情况a：

如果索引是相对于对角线行元素的。使用行列式的特性，将所有列元素都变为零。

情况b：

在这种情况下，我们需要交换具有相对于对角线元素列的行，并继续情况‘a’操作。

下面是上述方法的实现：

// C ++程序以找到矩阵的行列式
//计算机领域的英文文章
#include <bits/stdc++.h>
using namespace std;
 
// 输入方阵的维度
#define N 4
 
// 获取矩阵行列式的函数
int determinantOfMatrix(int mat[N][N], int n)
{
    // 初始化结果
    int num1, num2, det = 1, index,
                    total = 1;
 
    // 用于存储行的临时数组
    int temp[n + 1];
 
    // 遍历对角线元素的循环
    for (int i = 0; i < n; i++)
    {
        // 初始化索引
        index = i;
 
        // 找到具有非零值的索引
        while (index < n && mat[index][i] == 0)
        {
            index++;
        }
 
        // 如果有非零元素
        if (index == n)
        {
            // 矩阵的行列式为零
            continue;
        }
        if (index！= i)
        {
            // 交换对角线元素行和索引行的循环
            for (int j = 0; j < n; j++)
            {
                swap(mat[index][j], mat[i][j]);
            }
 
            // 当我们移动行穿过行列式时，行列式符号会更改
            // 属性
            det = det * pow(-1, index - i);
        }
 
        // 存储对角线行元素的值
        for (int j = 0; j < n; j++)
        {
            temp[j] = mat[i][j];
        }
 
        // 遍历对角线元素以下的每一行
        for (int j = i + 1; j < n; j++)
        {
            // 对角线元素的值
            num1 = temp[i];
 
            // 下一个行元素的值
            num2 = mat[j][i];
 
            // 遍历行的每一列并将其乘以每一行
            for (int k = 0; k < n; k++)
            {
                //乘以使对角线元素和下一行元素相等
                mat[j][k]
                    =（num1 * mat[j][k]） -（num2 * temp[k]）;
            }
            总数=总数* num1; // Det（kA）=kDet（A）;
        }
    }
 
    //将对角线元素相乘以获得行列式
    for (int i = 0; i < n; i++)
    {
        det = det * mat[i][i];
    }
 
    // Det（kA）/ k=Det（A）;
    返回（det / total）;
}
 
// 主函数
int main()
{
    int mat [N] [N] = {{1, 0, 2, -1},
                     {3, 0, 0, 5},
                     {2, 1, 4, -3},
                     {1, 0, 5, 0}};
 
    // 函数调用
    printf（"矩阵行列式为：％d"，
            determinantOfMatrix（mat，N））;
    回归0;
}

输出

矩阵行列式为：30

时间复杂度： O（n 3 ）

辅助空间： O（n）

方法：高斯-约旦消元法

步骤：

从所给矩阵开始，并将行列式初始化为1。
应用初等行操作，将矩阵转换为其行梯形形式，同时跟踪行列式。
如果执行了任何行交换操作，请将行列式乘以-1。
如果任何一行具有0的主导系数，则行列式为0，我们可以停止。
行列式是行梯形式中对角线条目的乘积。
返回行列式值。

#include<iostream>
using namespace std;
 
const int MAXN = 105;
double a[MAXN][MAXN];
double cofactor[MAXN][MAXN];
int sign = 1;
 
double determinant(int n) {
    if (n == 1) {
        return a[0][0];
    }
    double det = 0.0;
    for (int k = 0; k < n; k++) {
        int sub_i = 0;
        int sub_j = 0;
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (j == k) {
                    continue;
                }
                cofactor[sub_i][sub_j] = a[i][j];
                sub_j++;
                if (sub_j == n - 1) {
                    sub_i++;
                    sub_j = 0;
                }
            }
        }
        det += sign * a[0][k] * determinant(n - 1);
        sign = -sign;
    }
    return det;
}
 
int main() {
    int n = 4;
    double matrix[4][4] = {{1, 0, 2, -1},
                           {3, 0, 0, 5},
                           {2, 1, 4, -3},
                           {1, 0, 5, 0}};
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            a[i][j] = matrix[i][j];
        }
    }
    double det = determinant(n);
    cout << "Determinant = " << det << endl;
    return 0;
}