行列式的计算

行列式的众多正经的不正经的计算方法就属线性代数的内容了，这里不过多讨论，主要介绍代码中会用到的两种：

1. 公式计算
   行列式值的计算公式为
   $$\left|\begin{array}{cccc}{a}_{11}& a_{12}& \cdots & a_{1n}\\ a_{21}& a_{22}& \cdots & a_{2n}\\ ⋮& ⋮& \cdots & ⋮\\ a_{n1}& a_{n2}& \cdots & a_{nn}\end{array}\right|=\sum _{p_1{p}_2\cdots p_n}(-1{)}^{\tau \left(p_1{p}_2\cdots p_n\right)}{a}_{1p_1}{a}_{2p_2}\cdots a_{n{p}_n}$$
   其中$\tau$是序列$p_1{p}_2{p}_3{p}_4\cdots$中的逆序对数且各$p_i$互不相同。
2. 利用代数余子式进行计算
   结论：行列式等于它任意一行(列)的各元素与其对应的代数式余子式乘积之和。
   $$\begin{array}{rl}\left|\begin{array}{cccc}{a}_{11}& a_{12}& \cdots & a_{1n}\\ a_{21}& a_{22}& \cdots & a_{2n}\\ ⋮& ⋮& ⋮& ⋮\\ a_{n1}& a_{n2}& \cdots & a_{nn}\end{array}\right|=& a_{11}\left|\begin{array}{cccc}{a}_{22}& a_{23}& \cdots & a_{2n}\\ ⋮& ⋮& ⋮& ⋮\\ a_{n2}& a_{n3}& \cdots & a_{nn}\end{array}\right|-a_{12}\left|\begin{array}{cccc}{a}_{22}& a_{23}& \cdots & a_{2n}\\ ⋮& ⋮& ⋮& ⋮\\ a_{n2}& a_{n3}& \cdots & a_{nn}\end{array}\right|+\cdots +(-1{)}^{1+n}{a}_{1n}\left|\begin{array}{cccc}{a}_{21}& a_{22}& \cdots & a_{2,n-1}\\ ⋮& ⋮& ⋮& ⋮\\ a_{n1}& a_{n2}& \cdots & a_{n,n-1}\end{array}\right|\end{array}$$

1. 5阶矩阵行列式的计算

$$\left|\begin{array}{ccccc}{a}_{00}& a_{01}& a_{02}& a_{03}& a_{04}\\ a_{10}& a_{11}& a_{12}& a_{13}& a_{14}\\ a_{20}& a_{21}& a_{22}& a_{23}& a_{24}\\ a_{30}& a_{31}& a_{32}& a_{33}& a_{34}\\ a_{40}& a_{41}& a_{42}& a_{43}& a_{44}\end{array}\right|=\sum _{j_0{j}_1{j}_2{j}_3{j}_4}(-1{)}^{\tau \left(j_0{j}_1{j}_2{j}_3{j}_4\right)}{a}_{0j_0}{a}_{1j_1}{a}_{2j_2}{a}_{3j_3}{a}_{4j_4}$$
C++代码实现

#include<iostream>
#include<string>

using namespace std;

int main()
{   
	double a[5][5] = { 0 };
	double result = 0;
	int j0, j1, j2, j3, j4, inverse, flag;

	//输入矩阵
	cout << "请输入矩阵的25个数据：";
	for (int i = 0; i < 5; ++i)
		for (int j = 0; j < 5; ++j)
			cin >> a[i][j];

	for (j0 = 0; j0 < 4; ++j0){
	 inverse = 0;                    //逆序对初值
	 for (j1 = 0; j1 < 4; ++j1){
		 if (j1 == j0)  continue;    //排除j1和j0相等的情况
		 else if (j1 < j0) ++inverse;//若j1<j0,则逆序数+1
		 for (j2 = 0; j2 < 4; ++j2) {
			 if (j2 == j0 || j2 == j1) continue;
			 inverse += (j2 < j0) + (j2 < j1);//若j2<j0 则（j2<j0)的值为1；若j2>j0 则（j2<j0)的值为0
			 for (j3 = 0; j3 < 4; ++j3) {
				 if (j3 == j2 || j3 == j1 || j3 == j0)continue;
				 inverse += (j3 < j2) + (j3 < j1) + (j3 < j0);
				 for (j4 = 0; j4 < 4; ++j4)
					 if (j4 == j3 || j4 == j2 || j4 == j1 || j4 == j0) continue;
				     //j4可以不利用枚举法
				     //j4 = 10 - j0 - j1 - j2 - j3;
				     inverse += (j4 < j3) + (j4 < j2) + (j4 < j1) + (j4 < j0);

					 flag = (inverse % 2 == 0 ? 1 : -1);
					 result += flag * a[0][j0] * a[1][j1] * a[2][j2] * a[3][j3] * a[4][j4];
			 }
		 }
	 }
	}
	for (int m = 0; m < 5; ++m) {
		for (int n = 0; n < 5; ++n)
			cout << a[m][n] << " ";
		cout << endl;
	}
	cout << "行列式的值是" << result << endl;
	return 0;
}

运行结果如下：
注：为了能够简单验证结果的正确性，所以取的矩阵比较“好看”。

2. n阶矩阵行列式的计算

对于n阶矩阵来说，由于并不能在编程时确定其矩阵大小，上述方法则显得不是那么恰当，在这里利用指针构造动态数组进行计算。

动态数组和普通数组的最大区别在于，它的规模可以是运行程序过程种某一变量的值或某一表达式的计算结果，而普通数组的长度必须是在编译时就能确定的常量。

注：动态数组不能为数组元素赋初值

C++代码实现

#include <stdio.h>
#include <iostream>
using namespace std;

int det(int n, int** mat)//取矩阵的第一列进行运算
{
	int mov = 0;//记录a,b矩阵相对应的行数是否发生了改变
	int flag;
	int sum = 0;
	if (n == 1) return mat[0][0];
	int** b = new int* [n - 1];//创建第一列的n-1阶代数余子式矩阵
	for (int z = 0; z < n-1; ++z)
		b[z] = new int[n-1];//为每一行申请空间
	for (int i = 0; i < n; ++i)
	{
		for (int j = 0; j < n - 1; ++j) {
			mov = i > j ? 0 : 1;
			//b中行数小于此时a中所取行数即i时，可直接将a中j行搬到b中j行；
			//b中行数大于此时a中所取行数即i时，需将a中第j+1行搬运到b中j行；
			for (int k = 0; k < n - 1; ++k)//开始一行一行的搬运
				b[j][k] = mat[j + mov][k + 1];//k+1是因为在搬运过程中不取mat中第一列
		}
		if (i % 2 == 0) flag = 1;
		else flag = -1;//判断符号的正负，因为所取值为mat[0][i],所以需判断1+1+i=i+2的奇偶
		sum += flag * mat[i][0] * det(n - 1, b);
	}
	delete[] b;
	return sum;
}
int main()
{
	int n = 0;//矩阵阶数
	cout << "输入矩阵阶数：" << endl;
	cin >> n;
	int** a = new int* [n];//所要求的矩阵,因为矩阵阶数不是常数，so不能直接创建数组，以指针的形式呈现。
	for (int z = 0; z < n; ++z)
		a[z] = new int[n];//为每一行申请空间
	cout << "输入矩阵：" << endl;
	for (int x = 0; x < n; ++x)
		for (int y = 0; y < n; ++y)
			cin >> a[x][y];
	for (int x = 0; x < n; ++x)
	{
		cout << endl;
		for (int y = 0; y < n; ++y)
			cout << a[x][y] << " ";
	}
	cout << endl;
	cout << "矩阵行列式的值为：" << det(n, a);
	for (int p = 0; p < n; ++p)
		delete[] a[p];
	delete[]a;
	return 0;
}

灵感来源于：https://blog.csdn.net/sinat_36219858/article/details/54016698
这篇博文并未利用二级指针，而是利用数组储存了全部矩阵信息。

运行结果如下：

注：为了能够简单验证结果的正确性，所以取的矩阵比较“好看”。

当然，如果真的只是为了算个矩阵，仍旧强推MATLAB。

3. 踩坑记录

• 5阶矩阵的代码编写还是比较容易的，可以在此基础上进行改进，比如求个6阶，7阶也是可以的。
• n阶代码的确编了很长时间，可能是由于一学期不学线代+一学期不敲代码的原因，出了一些奇奇怪怪的错：

1. 循环的位置一定要看对，语句一定要放在正确的循环里。
2. 指针的基本操作要熟悉，要不不是忘了申请空间就是忘了释放空间
3. 行列要分清，不然。。。像我一样把 $mat[i][0]$写成$mat[0][i]$盯一下午？

• 顺便提醒一下，n阶的代码在VS上运行会报很多警告，大概是它跟多级2指针有仇，可以给大家看一眼：
  
  so，最后看不下去，用的codeblocks：
  
  距上一篇博客怕是已经半年了，这半年几乎没敲过代码（因为不上有关的课了）。下学期会学数据结构，so趁开学前几天把C++复习一下~

此处不在赘述行列式的数学求法。各位好友不会的还请自行补习。

知识点行列式的降阶计算 。

​
#include <iostream>
#include <cstdlib>
using namespace std;
#define N 100

int D[N][N];    //用于储存行列式 


int Deter(int a[][N], int u, int k)
{
    if(u == 1) return a[0][0];        //如果为一阶行列式直接输出结果
    if(u == 2) return a[0][0] * a[1][1] - a[0][1] * a[1][0];//二阶行列式直接输出结果
    int ans = 0;
    
    
    for(int i = 1; i < u; ++i)//i代表循环的次数
    {        
        int line = 0, row = 0;
        int D_new[N][N];    //用于存放新的降阶后的矩阵 
        for(int m = 1; m < u; ++m){
            for(int j = 0; j < u; ++j)//j代表列数 
            {    
                if(j == k) continue;            //此处的含义是删除含有k的这一列，与下面的k++相呼应
                D_new[line][++row] = a[m][j];
            }
            line++;     row = 0;
        }
        if(i % 2 == 0) ans -= a[0][i] * Deter(D_new, u - 1, 0), k++;//k的意思是删除这一列的数
        else ans += a[0][i] * Deter(D_new, u - 1, 0), k++;
    }
}


int main()
{
    int n;
    cout << "输入行列式的阶数：";
    cin >> n;
    for(int i = 0; i < n; ++i)
        for(int j = 0; j < n; ++j){
            cin >> D[i][j];
        } 
    int ans = 0;
    ans = Deter(D, n, 0);
    cout << ans;
    system("pause");
    return 0;
}

​

线性代数行列式计算之迭代法

声明与简介

线性代数行列式计算之迭代法是利用行列式逐阶展开式会发现或总结出n阶和n-1阶、n-2阶以及剩余阶的关系式，进而推算出整个行列式的最终结果。比如可以由  

  或反过来()，总之能找出一个逐级演变的推导关系式。迭代法又称之为递推法。

迭代法

正向迭代

根据给的行列式可以直观的找出n阶和n-1阶的关系式，这种方法叫做直接迭代法。详见如下示例：

计算n阶行列式：

#1 思路

Step1 先观察行列式的特点，再整理思路

Step2 如果我们对第1行应用行列式展开会出来2项，其中对应 的项和 在形式或者结构上是一样的，这样就形成了一种循环即迭代。

Step3 按照Step2的方法对n、n-1、n-2… 1阶进行展开进而得到最终结果。

#2 实操

Step1：按照第1行对行列(0多，实际仅2个元素)式进行展开

结果为：

Step2：因为 是 ,所以由上述总结的关系不难得出最终结果为：

推导总结

根据给的行列式可以间接找到找出n阶和n-1阶的关系式，然后再逐步降阶整理得到最终结果。详见如下示例：

计算n阶行列式

#1 思路

Step1 先观察行列式的特点，再整理思路

Step2 如果我们对第1行按照行列式代数余子式展开时不难发现会出现n阶和n-1阶的关系。

Step3 总结Step2里的规律，最终写出表达式和最终结果。

#2实操

Step1：按照第1行对原行列式展开

得如下结果

Step2: 我们对式子 做些变换

因为这里

， ，所以

Step3： 由Step2进而得到关系式

逐步降阶展开得到最后的结果为：