Java的高斯消元法

算法虽然会，但是用数组的形式进行求值是一件非常非常恶心的事情。

更恶心的是，公司里面的逻辑居然要用到方程组求解，万分无奈之下，上网找了一份Java代码。

谁知道居然是个算法数组从1开始的。

好吧，认了吧，我就把你改过来。

调试通过。

留个代码做纪念。

 

Java代码  

1. package com;  
2.   
3. public class EquationSolver {  
4.   
5.     /** 
6.      * @列主元高斯消去法 
7.      */  
8.     static double a[][];  
9.     static double b[];  
10.     static double x[];  
11.     static int n;  
12.     static int n2; //记录换行的次数  
13.     public static void Elimination(){  //消元  
14.         PrintA();  
15.         for(int k=0;k<n;k++)  
16.         {  
17.             Wrap(k);  
18.             for(int i=k+1;i<n;i++)  
19.             {  
20.                 double l=a[i][k]/a[k][k];  
21.                 a[i][k]=0.0;  
22.                 for(int j=k+1;j<n;j++)  
23.                     a[i][j]=a[i][j]-l*a[k][j];  
24.                 b[i]=b[i]-l*b[k];  
25.             }  
26.             System.out.println("第"+k+"次消元后：");  
27.             PrintA();  
28.         }  
29.                   
30.     }  
31.     public static void Back()//回代  
32.     {  
33.         x[n-1]=b[n-1]/a[n-1][n-1];  
34.         for(int i=n-2;i>=0;i--)  
35.             x[i]=(b[i]-jisuan(i))/a[i][i];  
36.     }  
37.     public static double jisuan(int i){  
38.         double he=0.0;  
39.         for(int j=i;j<=n-1;j++)  
40.             he=he+x[j]*a[i][j];  
41.         return he;  
42.     }  
43.     public static void Wrap(int k){//换行  
44.         double max=Math.abs(a[k][k]);  
45.         int n1=k;                   //记住要交换的行  
46.         for(int i=k+1;i<n;i++)     //找到要交换的行  
47.         {  
48.             if(Math.abs(a[i][k])>max){  
49.                 n1=i;  
50.                 max=Math.abs(a[i][k]);  
51.             }  
52.         }  
53.         if(n1!=k)  
54.         {  
55.             n2++;  
56.         System.out.println("当k="+k+"时,要交换的行是："+k+"和"+n1);  
57.         for(int j=k;j<n;j++)  //交换a的行  
58.         {  
59.             double x1;  
60.             x1=a[k][j];  
61.             a[k][j]=a[n1][j];  
62.             a[n1][j]=x1;  
63.         }  
64.         double b1;   //交换b的行  
65.         b1=b[k];  
66.         b[k]=b[n1];  
67.         b[n1]=b1;  
68.         System.out.println("交换后：");  
69.         PrintA();  
70.         }  
71.     }  
72.     public static void Determinant(){//求行列式  
73.         double DM=1.0;  
74.         for(int i=0;i<n;i++)  
75.         {  
76.             double a2=a[i][i];  
77.             DM=DM*a2;  
78.         }  
79.         double n3=(double)n2;  
80.         DM=DM*Math.pow(-1.0, n3);  
81.         System.out.println("该方程组的系数行列式：det A = "+DM);  
82.     }  
83.     public static void PrintA(){//输出增广矩阵  
84.         System.out.println("增广矩阵为：");  
85.         for(int i=0;i<n;i++)  
86.         {  
87.             for(int j=0;j<n;j++)  
88.                 System.out.print(a[i][j]+"    ");  
89.             System.out.print(b[i]+"    ");  
90.             System.out.print("\n");  
91.         }  
92.     }  
93.     public static void Print(){//输出方程的根  
94.         System.out.println("方程组的根为：");  
95.         for(int i=0;i<n;i++)  
96.             System.out.println("x"+i+" = "+x[i]);  
97.     }  
98.     public static void main(String[] args) {  
99.         //Scanner as=new Scanner(System.in);  
100.         System.out.println("输入方程组的元数：");  
101.         //n=as.nextInt();  
102.         n=2;  
103.         a=new double[n][n];  
104.         b=new double[n];  
105.         x=new double[n];  
106.           
107.         double inputA[][] = {{1,1},{1,-1}};  
108.         a = inputA;  
109.           
110.         double inputB[] = {2,0};  
111.         b = inputB;  
112.           
113.         double inputX[] = {1,1};  
114.           
115.         System.out.println("输入方程组的系数矩阵a：");  
116. //        for(int i=1;i<=n;i++)  
117. //          for(int j=1;j<=n;j++)  
118. //              a[i][j]=as.nextDouble();  
119.         System.out.println("输入方程组矩阵b：");  
120. //        for(int i=1;i<=n;i++)  
121. //          b[i]=as.nextDouble();  
122.         Elimination();  
123.         Back();  
124.         Print();  
125.         Determinant();  
126.     }  
127. }