前言

行列式求值对于刚刚学习完线性代数的大学生再熟悉不过了，同样于上一篇文章，这也是我们学习线性代数这个课程必须要掌握的知识点，但对于许多比较难算的题目，我依然想用代码帮助解决计算的问题，这种通过写代码来帮助我解决学习上的问题，能很大程度的提高我们写代码的能力，对于行列式的求值所需要写代码就简单多了。

一、对行列式的某行或某列进行操作

对于行列式的求值，我们通过公式就可以知道，需要将行列式的某一行或某一列的所有数通过加法或减法运算将该行或该列化为只有一个数不为0。同时再用这个数与它所对应的代数余子式相乘，通过不断的降低阶数，就能得到最终的运算结果。
输入很简单，与上一篇文章一样。
对于一阶二阶三阶这样的行列式直接进行简单的运算就可以了，而对于三阶以上的行列式我们需要做进一个操作。
代数余子式其中有一个(-1)(i+j)次方，为了确保这部分方程的值为1，我们可以将第一行第一个数作为第一列不需要改变的数，再将第一列其他的数通过与第一列进行运算使其他列的数全为0。因此，我们也要对第一行的第一个数进行判断是否为0。如果为0，那么在与其他行第一个数不为0的进行交换。如果某一列的所有数全为零，那么运算就直接结束了，最后输出0。

do {
  for(int i=0;i<A-C;i++)
  {
      if(B[i][0]!=0)
      {
          if(B[i][0]<0)
          {
              for(int j=0;j<A-C;j++)
              {
                  D=-B[i][j];
                  B[i][j]=B[0][j];
                  B[0][j]=D;
              }
              if(i!=0)
              {
                  fuhao*=(-1);
              }
              E=1;
              fuhao*=(-1);
              break;
          }
          else
          {
              for(int j=0;j<A-C;j++)
              {
                  D=B[i][j];
                  B[i][j]=B[0][j];
                  B[0][j]=D;
              }
              if(i!=0)
              {
                  fuhao*=(-1);
              }
              E=1;
              break;
          }
      }
  }

确定第一行第一个数不为0之后，再将其他行的第一个数，通过与第一行进行运算使其结果为0。

for(int i=1;i<A-C;i++)
{
    if(B[i][0]!=0)
    {
        if(B[i][0]<0)
        {
            for(F=B[0][0];F%(-B[i][0])!=0;)
                F+=B[0][0];
            F1=F/B[0][0];
            F2=F/(-B[i][0]);
            for(int j=0;j<A-C;j++)
            {
                B[i][j]=B[i][j]*F2+B[0][j]*F1;
            }
            G*=F2;
        }
        else
        {
            for(F=B[0][0];F%B[i][0]!=0;)
                F+=B[0][0];
            F1=F/B[0][0];
            F2=F/B[i][0];
            for(int j=0;j<A-C;j++)
            {
                B[i][j]=B[i][j]*F2-B[0][j]*F1;
            }
            G*=F2;
        }
    }
}

二.缩小矩阵的大小

之后一步操作比较关键，我们如何缩小我们的矩阵呢，最好的方法就是将矩阵中除第一行和第一列其他所有的数向左上角移动一位，这里需要一个数来记录化简过程中矩阵的大小，这个数最重要的作用是能知道在do——while语句中循环的次数。

I[C]=B[0][0];
C++;
System.out.println();
for(int i=0;i<A-C;i++)
{
    for(int j=0;j<A-C;j++)
    {
        B[i][j]=B[i+1][j+1];
    }
}

三、正负号处理和值存储之后进行除法运算

行列式的计算与矩阵的计算不同，行列式每一次行与行的交换或列与列的交换都会改变正负号。因此，我们要定义一个变量来记录这个正负号，同时行列式的计算当某一行或某一列乘以一个数时，那么这个行列式的计算结果就会扩大到所乘数的这么多倍。因此，还需要建立一个数组，将这些所乘的数储存起来，最后再统一做除法运算。

四.代码使用过程

五.整体代码

package zuopin;
import java.util.Scanner;
public class str {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        int A;
        System.out.println("行列式求值系统");
        System.out.println("请输入行列式的阶数：");
        do {
            A=input.nextInt();
            if(A<=0)
            {
                System.out.println("输入的行列式的阶数错误！");
                System.out.println("请重新输入：");
            }
        }while (A<=0);
        int [][]B=new int[A][A];
        for(int i=0;i<A;i++)
        {
            System.out.printf("请输入第%d行的所有数，每一个数之间用空格(或回车)隔开\n",i+1);
            for(int j=0;j<A;j++)
            {
                B[i][j]=input.nextInt();
            }
        }
        if(A==1)
        {
            System.out.println("运算结果为："+B[0][0]);
        }
        else
        if(A==2)
        {
            System.out.println("运算结果为："+(B[0][0]*B[1][1]-B[0][1]*B[1][0]));
        }
        else
        if(A==3)
        {
            System.out.println("运算结果为："+(B[0][0]*B[1][1]*B[2][2]+B[0][1]*B[1][2]*B[2][0]+B[0][2]*B[1][0]*B[2][1]-(B[2][0]*B[1][1]*B[0][2]+B[1][0]*B[0][1]*B[2][2]+B[0][0]*B[2][1]*B[1][2])));
        }
        else
        {
            int C=0,D,E=0,F,F1,F2,G=1,fuhao=1;
            int []I=new int[A-3];
            do {
                for(int i=0;i<A-C;i++)
                {
                    if(B[i][0]!=0)
                    {
                        if(B[i][0]<0)
                        {
                            for(int j=0;j<A-C;j++)
                            {
                                D=-B[i][j];
                                B[i][j]=B[0][j];
                                B[0][j]=D;
                            }
                            if(i!=0)
                            {
                                fuhao*=(-1);
                            }
                            E=1;
                            fuhao*=(-1);
                            break;
                        }
                        else
                        {
                            for(int j=0;j<A-C;j++)
                            {
                                D=B[i][j];
                                B[i][j]=B[0][j];
                                B[0][j]=D;
                            }
                            if(i!=0)
                            {
                                fuhao*=(-1);
                            }
                            E=1;
                            break;
                        }
                    }
                }
                if(E==0)
                {
                    System.out.println("运算结果为：0");
                    System.exit(0);
                }
                else
                {
                    for(int i=1;i<A-C;i++)
                    {
                        if(B[i][0]!=0)
                        {
                            if(B[i][0]<0)
                            {
                                for(F=B[0][0];F%(-B[i][0])!=0;)
                                    F+=B[0][0];
                                F1=F/B[0][0];
                                F2=F/(-B[i][0]);
                                for(int j=0;j<A-C;j++)
                                {
                                    B[i][j]=B[i][j]*F2+B[0][j]*F1;
                                }
                                G*=F2;
                            }
                            else
                            {
                                for(F=B[0][0];F%B[i][0]!=0;)
                                    F+=B[0][0];
                                F1=F/B[0][0];
                                F2=F/B[i][0];
                                for(int j=0;j<A-C;j++)
                                {
                                    B[i][j]=B[i][j]*F2-B[0][j]*F1;
                                }
                                G*=F2;
                            }
                        }
                    }
                }
                I[C]=B[0][0];
                C++;
                System.out.println();
                for(int i=0;i<A-C;i++)
                {
                    for(int j=0;j<A-C;j++)
                    {
                        B[i][j]=B[i+1][j+1];
                    }
                }
            }while(C<A-3);
            float H;
            H=B[0][0]*B[1][1]*B[2][2]+B[0][1]*B[1][2]*B[2][0]+B[0][2]*B[1][0]*B[2][1]-(B[2][0]*B[1][1]*B[0][2]+B[1][0]*B[0][1]*B[2][2]+B[0][0]*B[2][1]*B[1][2]);
            H=H*fuhao/(float)G;
            for(int i=0;i<A-3;i++)
            {
                H=H*I[i];
            }
            if(H==0)
            {
                System.out.println("运算结果为：0");
            }
            else
            {
                System.out.println("运算结果为："+H);
            }
        }
    }
}