矩阵的行列式

什么是矩阵的行列式?
矩阵的行列式是仅为平方矩阵(行和列数相同的矩阵)定义的特殊数字。行列式在微积分和其他与矩阵有关的代数中的许多地方都使用，它实际上以实数表示矩阵，可用于求解线性方程组和求矩阵的逆。

如何计算?
矩阵行列式的值可以通过以下过程计算得出–
对于第一行或第一列的每个元素，请获取这些元素的辅因子，然后将该元素与相应辅因子的行列式相乘，最后将它们与替代符号相加。作为基本情况，1 * 1矩阵的行列式的值本身就是单个值。

元素的辅因子是一个矩阵，我们可以从该矩阵中删除该元素的行和列。

2 x 2矩阵的行列式：

$A = \begin{bmatrix} a & b\\ c & d \end{bmatrix} \begin{vmatrix} A \end{vmatrix}= ad - bc$

3 x 3矩阵的行列式：

$A = \begin{bmatrix} a & b & c\\ d & e & f\\ g & h & i \end{bmatrix} \begin{vmatrix} A \end{vmatrix}= a(ei-fh)-b(di-gf)+c(dh-eg)$

C++

// C++ program to find Deteminant of a matrix
#include 
using namespace std;
 
// Dimension of input square matrix
#define N 4
 
// Function to get cofactor of mat[p][q] in temp[][]. n is
// current dimension of mat[][]
void getCofactor(int mat[N][N], int temp[N][N], int p,
                 int q, int n)
{
    int i = 0, j = 0;
 
    // Looping for each element of the matrix
    for (int row = 0; row < n; row++)
    {
        for (int col = 0; col < n; col++)
        {
            //  Copying into temporary matrix only those
            //  element which are not in given row and
            //  column
            if (row != p && col != q)
            {
                temp[i][j++] = mat[row][col];
 
                // Row is filled, so increase row index and
                // reset col index
                if (j == n - 1)
                {
                    j = 0;
                    i++;
                }
            }
        }
    }
}
 
/* Recursive function for finding determinant of matrix.
   n is current dimension of mat[][]. */
int determinantOfMatrix(int mat[N][N], int n)
{
    int D = 0; // Initialize result
 
    //  Base case : if matrix contains single element
    if (n == 1)
        return mat[0][0];
 
    int temp[N][N]; // To store cofactors
 
    int sign = 1; // To store sign multiplier
 
    // Iterate for each element of first row
    for (int f = 0; f < n; f++)
    {
        // Getting Cofactor of mat[0][f]
        getCofactor(mat, temp, 0, f, n);
        D += sign * mat[0][f]
             * determinantOfMatrix(temp, n - 1);
 
        // terms are to be added with alternate sign
        sign = -sign;
    }
 
    return D;
}
 
/* function for displaying the matrix */
void display(int mat[N][N], int row, int col)
{
    for (int i = 0; i < row; i++)
    {
        for (int j = 0; j < col; j++)
            printf("  %d", mat[i][j]);
        printf("n");
    }
}
 
// Driver program to test above functions
int main()
{
    /* int mat[N][N] = {{6, 1, 1},
                     {4, -2, 5},
                     {2, 8, 7}}; */
 
    int mat[N][N] = { { 1, 0, 2, -1 },
                      { 3, 0, 0, 5 },
                      { 2, 1, 4, -3 },
                      { 1, 0, 5, 0 } };
 
    // Function call
    printf("Determinant of the matrix is : %d",
           determinantOfMatrix(mat, N));
    return 0;
}

Java

// Java program to find Deteminant of
// a matrix
class GFG {
 
    // Dimension of input square matrix
    static final int N = 4;
 
    // Function to get cofactor of
    // mat[p][q] in temp[][]. n is
    // current dimension of mat[][]
    static void getCofactor(int mat[][], int temp[][],
                            int p, int q, int n)
    {
        int i = 0, j = 0;
 
        // Looping for each element of
        // the matrix
        for (int row = 0; row < n; row++)
        {
            for (int col = 0; col < n; col++)
            {
                // Copying into temporary matrix
                // only those element which are
                // not in given row and column
                if (row != p && col != q)
                {
                    temp[i][j++] = mat[row][col];
                    // Row is filled, so increase
                    // row index and reset col
                    // index
                    if (j == n - 1)
                    {
                        j = 0;
                        i++;
                    }
                }
            }
        }
    }
 
    /* Recursive function for finding determinant
    of matrix. n is current dimension of mat[][]. */
    static int determinantOfMatrix(int mat[][], int n)
    {
        int D = 0; // Initialize result
 
        // Base case : if matrix contains single
        // element
        if (n == 1)
            return mat[0][0];
 
        // To store cofactors
        int temp[][] = new int[N][N];
 
        // To store sign multiplier
        int sign = 1;
 
        // Iterate for each element of first row
        for (int f = 0; f < n; f++)
        {
            // Getting Cofactor of mat[0][f]
            getCofactor(mat, temp, 0, f, n);
            D += sign * mat[0][f]
                 * determinantOfMatrix(temp, n - 1);
 
            // terms are to be added with
            // alternate sign
            sign = -sign;
        }
 
        return D;
    }
 
    /* function for displaying the matrix */
    static void display(int mat[][], int row, int col)
    {
        for (int i = 0; i < row; i++)
        {
            for (int j = 0; j < col; j++)
                System.out.print(mat[i][j]);
 
            System.out.print("\n");
        }
    }
 
    // Driver code
    public static void main(String[] args)
    {
 
        int mat[][] = { { 1, 0, 2, -1 },
                        { 3, 0, 0, 5 },
                        { 2, 1, 4, -3 },
                        { 1, 0, 5, 0 } };
 
        System.out.print("Determinant "
                         + "of the matrix is : "
                         + determinantOfMatrix(mat, N));
    }
}
 
// This code is contributed by Anant Agarwal.

Python3

# python program to find
# determinant of matrix.
 
# defining a function to get the
# minor matrix after excluding
# i-th row and j-th column.
 
 
def getcofactor(m, i, j):
    return [row[: j] + row[j+1:] for row in (m[: i] + m[i+1:])]
 
# defining the function to
# calculate determinant value
# of given matrix a.
 
 
def determinantOfMatrix(mat):
 
    # if given matrix is of order
    # 2*2 then simply return det
    # value by cross multiplying
    # elements of matrix.
    if(len(mat) == 2):
        value = mat[0][0] * mat[1][1] - mat[1][0] * mat[0][1]
        return value
 
    # initialize Sum to zero
    Sum = 0
 
    # loop to traverse each column
    # of matrix a.
    for current_column in range(len(mat)):
 
        # calculating the sign corresponding
        # to co-factor of that sub matrix.
        sign = (-1) ** (current_column)
 
        # calling the function recursily to
        # get determinant value of
        # sub matrix obtained.
        sub_det = determinantOfMatrix(getcofactor(mat, 0, current_column))
 
        # adding the calculated determinant
        # value of particular column
        # matrix to total Sum.
        Sum += (sign * mat[0][current_column] * sub_det)
 
    # returning the final Sum
    return Sum
 
 
# Driver code
if __name__ == '__main__':
 
    # declaring the matrix.
    mat = [[1, 0, 2, -1],
           [3, 0, 0, 5],
           [2, 1, 4, -3],
           [1, 0, 5, 0]]
 
    # printing determinant value
    # by function call
    print('Determinant of the matrix is :', determinantOfMatrix(mat))
 
# This code is contributed by Amit Mangal.

C#

// C# program to find Deteminant of
// a matrix
using System;
class GFG {
 
    // Dimension of input square matrix
    static int N = 4;
 
    // Function to get cofactor of
    // mat[p][q] in temp[][]. n is
    // current dimension of mat[][]
    static void getCofactor(int[, ] mat, int[, ] temp,
                            int p, int q, int n)
    {
        int i = 0, j = 0;
 
        // Looping for each element of
        // the matrix
        for (int row = 0; row < n; row++)
        {
            for (int col = 0; col < n; col++)
            {
 
                // Copying into temporary matrix
                // only those element which are
                // not in given row and column
                if (row != p && col != q) {
                    temp[i, j++] = mat[row, col];
 
                    // Row is filled, so increase
                    // row index and reset col
                    // index
                    if (j == n - 1) {
                        j = 0;
                        i++;
                    }
                }
            }
        }
    }
 
    /* Recursive function for
       finding determinant
       of matrix. n is current
       dimension of mat[][]. */
    static int determinantOfMatrix(int[, ] mat, int n)
    {
        int D = 0; // Initialize result
 
        // Base case : if matrix
        // contains single
        // element
        if (n == 1)
            return mat[0, 0];
 
        // To store cofactors
        int[, ] temp = new int[N, N];
 
        // To store sign multiplier
        int sign = 1;
 
        // Iterate for each element
        // of first row
        for (int f = 0; f < n; f++)
        {
            // Getting Cofactor of mat[0][f]
            getCofactor(mat, temp, 0, f, n);
            D += sign * mat[0, f]
                 * determinantOfMatrix(temp, n - 1);
 
            // terms are to be added with
            // alternate sign
            sign = -sign;
        }
 
        return D;
    }
 
    /* function for displaying
       the matrix */
    static void display(int[, ] mat, int row, int col)
    {
        for (int i = 0; i < row; i++)
        {
            for (int j = 0; j < col; j++)
                Console.Write(mat[i, j]);
 
            Console.Write("\n");
        }
    }
 
    // Driver code
    public static void Main()
    {
 
        int[, ] mat = { { 1, 0, 2, -1 },
                        { 3, 0, 0, 5 },
                        { 2, 1, 4, -3 },
                        { 1, 0, 5, 0 } };
 
        Console.Write("Determinant "
                      + "of the matrix is : "
                      + determinantOfMatrix(mat, N));
    }
}
 
// This code is contributed by nitin mittal.

输出

Determinant of the matrix is : 30

C++

// C++ program to find Deteminant of a matrix
#include 
using namespace std;
 
// Dimension of input square matrix
#define N 4
// Function to get determinant of matrix
int determinantOfMatrix(int mat[N][N], int n)
{
    int num1, num2, det = 1, index,
                    total = 1; // Initialize result
 
    // temporary array for storing row
    int temp[n + 1];
 
    // loop for traversing the diagonal elements
    for (int i = 0; i < n; i++)
    {
        index = i; // initialize the index
 
        // finding the index which has non zero value
        while (mat[index][i] == 0 && index < n)
        {
            index++;
        }
        if (index == n) // if there is non zero element
        {
            // the determinat of matrix as zero
            continue;
        }
        if (index != i)
        {
            // loop for swaping the diagonal element row and
            // index row
            for (int j = 0; j < n; j++)
            {
                swap(mat[index][j], mat[i][j]);
            }
            // determinant sign changes when we shift rows
            // go through determinant properties
            det = det * pow(-1, index - i);
        }
 
        // storing the values of diagonal row elements
        for (int j = 0; j < n; j++)
        {
            temp[j] = mat[i][j];
        }
        // traversing every row below the diagonal element
        for (int j = i + 1; j < n; j++)
        {
            num1 = temp[i]; // value of diagonal element
            num2 = mat[j][i]; // value of next row element
 
            // traversing every column of row
            // and multiplying to every row
            for (int k = 0; k < n; k++)
            {
                // multiplying to make the diagonal
                // element and next row element equal
                mat[j][k]
                    = (num1 * mat[j][k]) - (num2 * temp[k]);
            }
            total = total * num1; // Det(kA)=kDet(A);
        }
    }
 
    // mulitplying the diagonal elements to get determinant
    for (int i = 0; i < n; i++)
    {
        det = det * mat[i][i];
    }
    return (det / total); // Det(kA)/k=Det(A);
}
 
// Driver code
int main()
{
    /*int mat[N][N] = {{6, 1, 1},
                        {4, -2, 5},
                        {2, 8, 7}}; */
 
    int mat[N][N] = { { 1, 0, 2, -1 },
                      { 3, 0, 0, 5 },
                      { 2, 1, 4, -3 },
                      { 1, 0, 5, 0 } };
 
    // Function call
    printf("Determinant of the matrix is : %d",
           determinantOfMatrix(mat, N));
    return 0;
}

Java

// Java program to find Deteminant of a matrix
class GFG
{
 
    // Dimension of input square matrix
    static final int N = 4;
 
    // Function to get determinant of matrix
    static int determinantOfMatrix(int mat[][], int n)
    {
        int num1, num2, det = 1, index,
                        total = 1; // Initialize result
 
        // temporary array for storing row
        int[] temp = new int[n + 1];
 
        // loop for traversing the diagonal elements
        for (int i = 0; i < n; i++)
        {
            index = i; // initialize the index
 
            // finding the index which has non zero value
            while (mat[index][i] == 0 && index < n)
            {
                index++;
            }
            if (index == n) // if there is non zero element
            {
                // the determinat of matrix as zero
                continue;
            }
            if (index != i)
            {
                // loop for swaping the diagonal element row
                // and index row
                for (int j = 0; j < n; j++)
                {
                    swap(mat, index, j, i, j);
                }
                // determinant sign changes when we shift
                // rows go through determinant properties
                det = (int)(det * Math.pow(-1, index - i));
            }
 
            // storing the values of diagonal row elements
            for (int j = 0; j < n; j++)
            {
                temp[j] = mat[i][j];
            }
 
            // traversing every row below the diagonal
            // element
            for (int j = i + 1; j < n; j++)
            {
                num1 = temp[i]; // value of diagonal element
                num2 = mat[j]
                          [i]; // value of next row element
 
                // traversing every column of row
                // and multiplying to every row
                for (int k = 0; k < n; k++)
                {
                    // multiplying to make the diagonal
                    // element and next row element equal
                    mat[j][k] = (num1 * mat[j][k])
                                - (num2 * temp[k]);
                }
                total = total * num1; // Det(kA)=kDet(A);
            }
        }
 
        // mulitplying the diagonal elements to get
        // determinant
        for (int i = 0; i < n; i++)
        {
            det = det * mat[i][i];
        }
        return (det / total); // Det(kA)/k=Det(A);
    }
 
    static int[][] swap(int[][] arr, int i1, int j1, int i2,
                        int j2)
    {
        int temp = arr[i1][j1];
        arr[i1][j1] = arr[i2][j2];
        arr[i2][j2] = temp;
        return arr;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        /*int mat[N][N] = {{6, 1, 1},
                        {4, -2, 5},
                        {2, 8, 7}}; */
 
        int mat[][] = { { 1, 0, 2, -1 },
                        { 3, 0, 0, 5 },
                        { 2, 1, 4, -3 },
                        { 1, 0, 5, 0 } };
 
        // Function call
        System.out.printf(
            "Determinant of the matrix is : %d",
            determinantOfMatrix(mat, N));
    }
}
 
// This code is contributed by Rajput-Ji

Python3

# Python program to find Determinant of a matrix
 
 
def determinantOfMatrix(mat, n):
 
    temp = [0]*n  # temporary array for storing row
    total = 1
    det = 1  # initialize result
 
    # loop for traversing the diagonal elements
    for i in range(0, n):
        index = i  # initialize the index
 
        # finding the index which has non zero value
        while(mat[index][i] == 0 and index < n):
            index += 1
 
        if(index == n):  # if there is non zero element
            # the determinat of matrix as zero
            continue
 
        if(index != i):
            # loop for swaping the diagonal element row and index row
            for j in range(0, n):
                mat[index][j], mat[i][j] = mat[i][j], mat[index][j]
 
            # determinant sign changes when we shift rows
            # go through determinant properties
            det = det*int(pow(-1, index-i))
 
        # storing the values of diagonal row elements
        for j in range(0, n):
            temp[j] = mat[i][j]
 
        # traversing every row below the diagonal element
        for j in range(i+1, n):
            num1 = temp[i]     # value of diagonal element
            num2 = mat[j][i]   # value of next row element
 
            # traversing every column of row
            # and multiplying to every row
            for k in range(0, n):
                # multiplying to make the diagonal
                # element and next row element equal
 
                mat[j][k] = (num1*mat[j][k]) - (num2*temp[k])
 
            total = total * num1  # Det(kA)=kDet(A);
 
    # mulitplying the diagonal elements to get determinant
    for i in range(0, n):
        det = det*mat[i][i]
 
    return int(det/total)  # Det(kA)/k=Det(A);
 
 
# Drivers code
if __name__ == "__main__":
    # mat=[[6 1 1][4 -2 5][2 8 7]]
 
    mat = [[1, 0, 2, -1], [3, 0, 0, 5], [2, 1, 4, -3], [1, 0, 5, 0]]
    N = len(mat)
     
    # Function call
    print("Determinant of the matrix is : ", determinantOfMatrix(mat, N))

C＃

// C# program to find Deteminant of a matrix
using System;
 
class GFG {
 
    // Dimension of input square matrix
    static readonly int N = 4;
 
    // Function to get determinant of matrix
    static int determinantOfMatrix(int[, ] mat, int n)
    {
        int num1, num2, det = 1, index,
                        total = 1; // Initialize result
 
        // temporary array for storing row
        int[] temp = new int[n + 1];
 
        // loop for traversing the diagonal elements
        for (int i = 0; i < n; i++)
        {
            index = i; // initialize the index
 
            // finding the index which has non zero value
            while (mat[index, i] == 0 && index < n)
            {
                index++;
            }
            if (index == n) // if there is non zero element
            {
                // the determinat of matrix as zero
                continue;
            }
            if (index != i)
            {
                // loop for swaping the diagonal element row
                // and index row
                for (int j = 0; j < n; j++)
                {
                    swap(mat, index, j, i, j);
                }
                // determinant sign changes when we shift
                // rows go through determinant properties
                det = (int)(det * Math.Pow(-1, index - i));
            }
 
            // storing the values of diagonal row elements
            for (int j = 0; j < n; j++)
            {
                temp[j] = mat[i, j];
            }
 
            // traversing every row below the diagonal
            // element
            for (int j = i + 1; j < n; j++)
            {
                num1 = temp[i]; // value of diagonal element
                num2 = mat[j,
                           i]; // value of next row element
 
                // traversing every column of row
                // and multiplying to every row
                for (int k = 0; k < n; k++)
                {
 
                    // multiplying to make the diagonal
                    // element and next row element equal
                    mat[j, k] = (num1 * mat[j, k])
                                - (num2 * temp[k]);
                }
                total = total * num1; // Det(kA)=kDet(A);
            }
        }
 
        // mulitplying the diagonal elements to get
        // determinant
        for (int i = 0; i < n; i++)
        {
            det = det * mat[i, i];
        }
        return (det / total); // Det(kA)/k=Det(A);
    }
 
    static int[, ] swap(int[, ] arr, int i1, int j1, int i2,
                        int j2)
    {
        int temp = arr[i1, j1];
        arr[i1, j1] = arr[i2, j2];
        arr[i2, j2] = temp;
        return arr;
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        /*int mat[N,N] = {{6, 1, 1},
                        {4, -2, 5},
                        {2, 8, 7}}; */
 
        int[, ] mat = { { 1, 0, 2, -1 },
                        { 3, 0, 0, 5 },
                        { 2, 1, 4, -3 },
                        { 1, 0, 5, 0 } };
 
        // Function call
        Console.Write("Determinant of the matrix is : {0}",
                      determinantOfMatrix(mat, N));
    }
}
 
// This code is contributed by 29AjayKumar

输出

Determinant of the matrix is : 30

时间复杂度： O(n ³ )
辅助空间： O(n)

方法3：在Python使用numpy包

在Python的numpy包的linalg模块中有一个内置函数或方法。可以将其称为numpy.linalg.det(mat)，它返回论证中传递的矩阵mat的行列式值。

Python3

# importing the numpy package
# as np
import numpy as np
 
def determinant(mat):
     
    # calling the det() method
    det = np.linalg.det(mat)
    return round(det)
 
# Driver Code
# declaring the matrix
mat = [[1, 0, 2, -1],
       [3, 0, 0, 5],
       [2, 1, 4, -3],
       [1, 0, 5, 0]]
 
# Function call
print('Determinant of the matrix is:',
      determinant(mat))
 
# This code is contributed by Amit Mangal.

输出：

Determinant of the matrix is: 30.0