行列式求值（C++）

对于行列式的求值主要有三种方法：①对角线相乘②行列式展开③代数余子式计算。

1. 对角线相乘
   对角线相乘需要行列式满足特定的要求，如上三角、下三角或者对角阵，否则不能直接使用此方法。如果需要使用这个方法，则需要对行列式进行初等行变换，直到满足要求。
   初等行变换性质：

   1. 交换任意两行，行列式的值变为相反数。
   2. 把某一行乘以一个非零数加到另外一行行列式的值不变。
   3. 行列式转置后，行列式的值不变，因此上述性质同样适用于列变换的情况。
      $$|D|=\prod _{i=1}^n{a}_{ii}$$

   //采用上三角转换的方法求行列式的值
   #include 
   #include//这个头文件仅仅是用来设置cout的输出精度
   double determinant_value(double **D,int n)
   {
       if(n==1)
       {
           return D[0][0];
       }
       else if(n==0){
           throw "error: determinant is empty";
       }
       char flag = 1;//符号位
       double D_value = 0.0;
       //转为上三角
       for (int i = 0; i < n; i++)
       {
           if(D[i][i]==0)
           {
               int j = i + 1;
               //将主对角线上的值转为非0值
               for(;j>n;//n维
       double **D=new double *[n];
       std::cout<<"请输入矩阵的元素:"<>D[i][j];//每次输入一个数字都用空格隔开,输入样例
               //1 2 3\enter
               //4 5 6\enter
               //7 8 9\enter
           }
       }
       
       std::cout<<"行列式的值"<

   测试结果如下：
   

2. 行列式展开
   此方法多用于二阶、三阶行列式，对于高阶行列式计算比较困难，展开项数多达$n!$项，四阶行列式展开多达24项，计算量非常大。
   二阶
   $$|D|=d_{11}\ast d_{22}-d_{12}\ast d_{21}$$
   三阶
   $$\begin{gathered} |D|=d_{11}\ast d_{22}\ast d_{33}+d_{12}\ast d_{23}\ast d_{31}+d_{13}\ast d_{21}\ast d_{32}- \\ {d}_{11}\ast d_{23}\ast d_{32}-d_{12}\ast d_{21}\ast d_{33}-d_{13}\ast d_{22}\ast d_{31} \end{gathered}$$
   任意阶
   D n = ∣ d 11 d 12 ⋯ d 1 n d 21 d 22 ⋯ d 2 n ⋮ ⋮ ⋮ d n 1 d n 2 ⋯ d n n ∣ = ∑ ( − 1 ) t d 1 p 1 d 2 p 2 ⋯ d n p n D_n=\left|\begin {array}{c} d_{11} &d_{12} &\cdots &d_{1n}\\ d_{21} &d_{22} &\cdots &d_{2n} \\ \vdots & \vdots & & \vdots \\ d_{n1} &d_{n2} &\cdots &d_{nn} \\ \end{array}\right|=\sum(-1)^td_{1p_{1}}d_{2p_{2}}\cdots d_{np_{n}} Dn​= ​d11​d21​⋮dn1​​d12​d22​⋮dn2​​⋯⋯⋯​d1n​d2n​⋮dnn​​ ​=∑(−1)td1p1​​d2p2​​⋯dnpn​​
   此处的t为排列$p_1{p}_2\cdots p_n$的逆序数，且互不相同。

3. 代数余子式计算
   以三阶行列式为例，计算公式如下：
   D = ∣ d 11 d 12 d 13 d 21 d 22 d 23 d 31 d 32 d 33 ∣ = ∑ ( − 1 ) i + j d i j M i j D=\left|\begin {array}{c} d_{11} &d_{12} &d_{13}\\ d_{21} &d_{22} &d_{23} \\ d_{31} &d_{32} &d_{33} \\ \end{array}\right|=\sum(-1)^{i+j}d_{ij}M_{ij} D= ​d11​d21​d31​​d12​d22​d32​​d13​d23​d33​​ ​=∑(−1)i+jdij​Mij​
   $M_{ij}$为原行列式D去除第i行和第j列后的行列式。
   对于高阶的行列式可以将其不断展开直至其为二阶或者三阶行列式后，再进行计算，简化了计算流程。
   由于其具有递归属性，因此使用该方法在程序计算行列式的值较为简单。

   #include
   using namespace std;
   /*
   6
   3 7.9 8.7 3.7 2.1 1.5
   4.1 1.0 0.2 1.1 7.8 9.2
   33.4 1.9 22 15 17 19.3
   27.5 29.3 1.1 0.11 0 1.2
   -1 -3.4 -7.5 1.2 1.4 7.7
   6.8 17.9 22.6 5.7 33.4 -18
   1.45056e+07
   */
   //使用代数余子式进行求解
   float determinant_value(float **D,int n)
   {
       //递归终点
       if(n==1)
       {
           return  D[0][0];
       }
       else if(n==2)
       {
           return D[1][1]*D[0][0]-D[0][1]*D[1][0];
       }
       else{
           float D_value=0;
           for(int k=0;k>n;//n维
       float **D=new float *[n];
       cout<<"请输入矩阵的元素:"<>D[i][j];//每次输入一个数字都用空格隔开,输入样例
               //1 2 3\enter
               //4 5 6\enter
               //7 8 9\enter
           }
       }
       cout<

   其运行结果如下：
   

   由于没有使用setprecision函数对输出精度进行控制，所以只输出了整数位，两种代码都可以完成行列式的值的计算，但是更加推荐第一种方法，因为对于高阶矩阵，第二种方法的空间复杂度和时间复杂度较高，不利于计算。