C#算法应用之高斯消元法实现

// 程 序 名：GaussP1.cs  
// 主要功能：利用高斯消元法求线性方程组的解  


// 注意：  
//     本程序详细地给出了中间过程，以便在调试时分析解题过程，适合于教学。  
// 适合于实际计算的另一个程序名为：GuassP1.pas  
 
using System;                                         // 引入System命名空间  
 
namespace GaussP1  
{  
  public class Program  
  {  
    public static void Main(string[] args)            // 主函数  
    {                                                 // 主函数开始  
      // 为了简化程序，本例只考虑方程组有***解的情况，不对其它情况进行判断。  
      // n是线性方程组的个数，数组a是增广矩阵，为了方便调试，在这里直接给n和  
      // 数组a赋值，在实际使用过程中要通过键盘读入它们的值  
      int n = 3;   
      double[,] a = {{2, -1, 3, 1}, {4, 2, 5, 4}, {1, 2, 0, 7}};  
      double[] x = new double[n];  
 
      Gauss(n, a, x);  
 
      // 输出方程组的解  
      Console.WriteLine("方程组的解为：");  
      for(int i = 0; i < n; i++) Console.Write("x({0})={1,8:F3} ", i, x[i]);  
      Console.WriteLine();  
    }  
 
    // 利用高斯消元法求线性方程组的解  
    public static void Gauss(int n, double[,] a, double[] x)  
    {  
      double d;  
 
      Console.WriteLine("高斯消去法解方程组的中间过程");  
      Console.WriteLine("============================");  
      Console.WriteLine("中间过程");  
      Console.WriteLine("增广矩阵：");  
      printArray(n, a); Console.WriteLine();  
        
      // 消元  
      for(int k = 0; k < n; k++)  
      {  
        Console.WriteLine("第{0}步", k + 1);  
        Console.WriteLine("初始矩阵：");  
        printArray(n, a); Console.WriteLine();  
 
        selectMainElement(n, k, a); // 选择主元素  
        Console.WriteLine("选择主元素后的矩阵：");  
        printArray(n, a); Console.WriteLine();  
 
        // for (int j = k; j <= n; j++ ) a[k, j] = a[k, j] / a[k, k];  
        // 若将下面两个语句改为本语句，则程序会出错，因为经过第1次循环  
        // 后a[k,k]=1，a[k,k]的值发生了变化，所以在下面的语句中先用d  
        // 将a[k,k]的值保存下来  
        d = a[k, k];  
        for (int j = k; j <= n; j++ ) a[k, j] = a[k, j] / d;  
        Console.WriteLine("将第{0}行中a[{0},{0}]化为1后的矩阵：", k + 1);  
        printArray(n, a); Console.WriteLine();  
 
        // Guass消去法与Jordan消去法的主要区别就是在这一步，Gauss消去法是从k+1  
        // 到n循环，而Jordan消去法是从1到n循环，中间跳过第k行  
        for(int i = k + 1; i < n; i++)  
        {  
           d = a[i, k];  // 这里使用变量d将a[i,k]的值保存下来的原理与上面注释中说明的一样  
           for (int j = k; j <= n; j++) a[i, j] = a[i, j] - d * a[k, j];  
        }  
 
        Console.WriteLine("消元后的矩阵：");  
        printArray(n, a); Console.WriteLine();  
      }  
 
      // 回代  
      x[n - 1] = a[n - 1, n];  
      for (int i = n - 1; i >= 0; i--)  
      {  
        x[i] = a[i, n];  
        for (int j = i + 1; j < n; j++) x[i] = x[i] - a[i, j] * x[j];  
      }  
    }  
 
    // 选择主元素  
    public static void selectMainElement(int n, int k, double[,] a)  
    {  
      // 寻找第k列的主元素以及它所在的行号  
      double t, mainElement;            // mainElement用于保存主元素的值  
      int l;                            // 用于保存主元素所在的行号  
 
      // 从第k行到第n行寻找第k列的主元素，记下主元素mainElement和所在的行号l  
      mainElement = Math.Abs(a[k, k]);  // 注意别忘了取绝对值  
      l = k;  
      for(int i = k + 1; i < n; i++)  
      {  
        if (mainElement < Math.Abs(a[i, k]))  
        {  
          mainElement = Math.Abs(a[i, k]);  
          l = i;                        // 记下主元素所在的行号  
        }  
      }  
 
      // l是主元素所在的行。将l行与k行交换，每行前面的k个元素都是0，不必交换  
      if (l != k)  
      {  
        for (int j = k; j <= n; j++)  
        {   
          t = a[k, j]; a[k, j] = a[l, j]; a[l, j] = t;  
        }  
      }  
    }  
 
    // 打印矩阵  
    public static void printArray(int n, double[,] a)  
    {  
      for(int i = 0; i < n; i++)  
      {  
        for (int j = 0; j <= n; j++ ) Console.Write("{0,10:F6} ", a[i, j]);  
        Console.WriteLine();  
      }  
    }  
  }  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.