列主元消去法求解线性方程组（C++实现）

接着上次的继续，上次使用了高斯消元法http://blog.csdn.net/qq_26025363/article/details/53027926，但是，在消元过程中，无法使主元素a(ii)≠0，但是很小时，用其做除数，会导致其他元素数量级的严重增长，舍入误差的扩展，最后导致计算结果不可靠。所以这次采用列主元素消去法来进行，思想就是将有小数的那行与该列中数最大的那行进行交换。
还是写帖代码吧

#include<iostream>
#include<cmath>
using namespace std;

const int n = 3;
//交换2个数的大小
template<class T>
void SWAP(T& a, T& b)
{
    T c;
    c = a;
    a = b;

    b = c;
}

//高斯列主元素消元法
void gaussin_L(double a[n][n], double b[n])
{

    int i, j, k;
    int col, row;
    for (k = 0; k < n - 1; k++)
    {
        double ave = 0;
        //找出消元列中最大的那个元素所在的位置
        for (i = k; i < n ; i++)
            if (fabs(a[i][k]) > ave)
            {
                ave = fabs(a[i][k]);
                cout << "ave " << ave << endl;
                row = i;
                col = k;
    }

        //如果该对角线元素是0，同样不能用高斯消元法来求解
        if (a[row][row] == 0)
        {
            cout << "can't solve" << endl;
            return;
        }
        //将找出的行进行交换
        if (k != row)
            for (i = 0; i < n; i++)
            {

                        SWAP(a[row][i], a[k][i]);

                        SWAP(b[k], b[row]);
            }
        //消元过程
        double c[n];
        for (j = k + 1; j < n; j++)
        {
            c[j] = a[j][k] / a[k][k];
            cout << c[j] << endl;
        }
        for (i = k + 1; i < n; i++)
        {
            for (j = 1; j < n; j++)
            {
                a[i][j] = a[i][j] - c[i] * a[k][j];
            }
            b[i] = b[i] - c[i] * b[k];
        }

    }

    double x[n];
    x[n - 1] = b[n - 1] / a[n - 1][n - 1];
    for (i = n - 2; i >= 0; i--)
    {

        double sum = 0；
        for (j = i + 1; j < n; j++)
            sum += a[i][j] * x[j];
        x[i] = (b[i] - sum)/a[i][i];
    }
    //打印输出
    for (i = 0; i < n ; i++)
        cout << " x" << "[" << i << "]=" << x[i] << endl;
}

`

对于该算法，简要的分析一下吧，该算法基本还是没有脱离高斯消元法，仅仅是稍微进行一个排序，减少了误差，但是也增加了个排序的时间消耗，其他跟高斯消元法没有区别，但是如果还想提高误差精度之类的话，可以采用行列住元消去法，就是从整个矩阵中挑选出最大的那个数，作为除数，然后消元，接着挑第二次消元矩阵中最大的数进行消元。

==================================测试代码`

int main()
{
double a[3][3] ={0.001,2.000,3.000,-1.000,3.712,4.623,-2.000,1.072,5.643};
double b[3] = { 1.000,2.000,3.000 };
gaussin_L(a, b);
return 0;
}

对于结果，其实误差也不小，到小数点后4位左右就不准了，但是如果换其他的浮点数运算
对于结果，有时候误差能把你吓傻，这个方法还是不理想。如果对于这个大家有问题，欢迎多交流~