【计算方法】#01 高斯消去法和列主元高斯消去法的原理简介及C++实现

求解方程组：$Ax=b$

1. 高斯消去法

1.1 算法的适用条件

满足以下条件中的任一即可

1. 系数矩阵$A$的各阶顺序主子式均不等于零(充要)；

2. 系数矩阵$A$是对称正定矩阵；

3. 系数矩阵$A$是严格对角占优矩阵，即对角线元素大于对应行的其余元素之和。

1.2 算法步骤和公式

消元过程(第$k$次消元)：
$$\{\begin{array}{ll}& a_{ij}^{(k)}=a_{ij}^{(k-1)}-\frac{a_{ik}^{(k-1)}}{a_{kk}^{(k-1)}}{a}_{kj}^{(k-1)}=a_{ij}^{(k-1)}-l_{ik}{a}_{kj}^{(k-1)},\\ & i=k+1,k+2,...,n;j=k+1,k+2,...,n\\ & \\ & b_i^{(k)}=b_i^{(k-1)}-l_{ik}{b}_k^{(k-1)},i=k+1,k+2,...,n\\ & \\ & l_{ik}\triangleq \frac{a_{ik}^{(k-1)}}{a_{kk}^{(k-1)}},i=k+1,k+2,...,n\end{array}$$

回代过程：
$$\{\begin{array}{rl}{x}_n& =\frac{b_n^{(n-1)}}{a_{nn}^{(n-1)}},\\ x_k& =\frac{b_k^{(k-1)}-\sum _{j=k+1}^n{a}_{kj}^{(k-1)}{x}_j}{a_{kk}^{(k-1)}},k=n-1,n-2,...,2,1\end{array}$$

1.3 算法复杂度分析

令运算量为乘除法个数，则

消元过程：$N_1=\sum _{k=1}^{n-1}(n-k{)}^2+2(n-k)=n^3/3+n^2/2-5n/6$

回代过程：$N_2=1+(n-1)+\sum _{k=1}^{n-1}(n-k)=n^2/2+n/2$

高斯消去法总运算量：$N=N_1+N_2=n^3/3+n^2-n/3$

时间复杂度：$O(n^3)$

空间复杂度：$O(n^2)$，开销为系数矩阵$A$和一维数组$b$

1.4 算法的C++实现

typedef float elem;
vector<elem> Gauss_Elimination(vector<vector<elem>>& A, 
					vector<elem>& b, elem epsilon){
    /* 高斯消去法
    参数简介：
        A - n维的系数矩阵
        b - 方程组等号右边的向量，维度1xn
        epsilon - 矩阵元素的阈值，当主元过小时高斯消去法将数值不稳定
    使用前的约定：
        1. 确保A不为空，且Ax=b中各个参数的维度一致
    注：执行完后，A和b将会改变
    */
    int n = A.size();
    vector<elem> x(n);
    // 消元过程
    for (int k=0; k<n-1; ++k){ // 第k+1步消元
        // 主元太小，不能继续
        if(abs(A[k][k]) < epsilon){
            cout<<"The pivot element is too small. Process aborted."<<endl;
            return {};
        }
        for (int i=k+1; i<n; ++i){ // l[i][k]
            A[i][k] /= A[k][k];
        }
        // b[i]
        for (int i=k+1; i<n; ++i){
            b[i] -= A[i][k]*b[k];
        }
        // A[i][j]
        for (int i=k+1; i<n; ++i){
            for (int j=k+1; j<n; ++j){
                A[i][j] -= A[i][k] * A[k][j];
            }
        }
    }
    // 回代过程  
    for (int k=n-1; k>=0; --k){
        
        for (int j=k+1; j<n; ++j){
            b[k] -= A[k][j] * x[j];
        }
        x[k] = b[k] / A[k][k];
    }
    return x;
}

2 列主元高斯消去法

2.1 经典方法的致命问题

$(|A|\ne 0)\nRightarrow (a_{kk}^{(k-1)}\ne 0)$，即使$a_{kk}^{(k-1)}\ne 0$，但$|a_{kk}^{(k-1)}|$很小，这就会引起其他元素数量级的剧增和舍入误差的增长，导致计算结果不可靠，甚至计算不能进行下去(上溢)。

2.2 按列选主元步骤的算法描述

相比经典的高斯消去法，在消元过程前额外多了按列选主元步骤和交换行步骤，其余流程是一致的。

按列选主元步骤的算法描述： 选取第$k$列的主元，即寻找它所在的行$q$，有：
$$q=\underset{i\in [k,n)}{\mathrm{argmax}}|a_{ik}|$$

交换行步骤的算法描述： 找到主元所在行$q$后，分别交换$A$和$b$的第$k$行和第$q$行元素，即
$$\{\begin{array}{ll}& \mathrm{s}\mathrm{w}\mathrm{a}\mathrm{p}({\mathrm{a}}_{\mathrm{k}\mathrm{j}},{\mathrm{a}}_{\mathrm{q}\mathrm{j}}),\mathrm{j}=\mathrm{k},\mathrm{k}+1,...,\mathrm{n}\\ & \mathrm{s}\mathrm{w}\mathrm{a}\mathrm{p}({\mathrm{b}}_{\mathrm{k}},{\mathrm{b}}_{\mathrm{q}})\end{array}$$

2.3 算法复杂度分析

时间复杂度：$O(n^3)$，增加的两个步骤的复杂度均为$O(n)$

空间复杂度：$O(n^2)$

2.4 算法优势

1. 由于$|a_{ik}^{(k-1)}|/|a_{kk}^{(k-1)}|\le 1(i=k+1,...,n)$，列主元消去法有利于控制误差的传播，故具有较好的数值稳定性；

2.5 算法的C++实现

typedef float elem;
vector<elem> Gauss_Elimination_ColumnPivot(vector<vector<elem>>& A, 
							vector<elem>& b, elem epsilon){
    /* 列主元的高斯消去法
    参数简介：
        A - n维的系数矩阵
        b - 方程组等号右边的向量，维度1xn
        epsilon - 矩阵元素的阈值，当主元过小时高斯消去法将数值不稳定
    使用前的约定：
        1. 确保A不为空，且Ax=b中各个参数的维度一致
    注：执行完后，A和b将会改变
    */
    int n = A.size();
    vector<elem> x(n);
    // 消元过程
    for (int k=0; k<n-1; ++k){ // 第k+1步消元
        elem maxf = 0;
        int q; // 最大主元所在行
        // 选主元
        for (int i=k; i<n; ++i){
            if(abs(maxf) < abs(A[i][k])){
                maxf = A[i][k];
                q = i;
            }
        }
        // 主元太小，不能继续
        if(abs(maxf) < epsilon){
            cout<<"The pivot element is too small. Process aborted."<<endl;
            return {};
        }
        // 交换行
        if(q != k){
            for (int j=k; j<n; ++j){
                swap(A[q][j], A[k][j]);
            }
            swap(b[q], b[k]);
        }
        // 消元过程
        for (int i=k+1; i<n; ++i){ // l[i][k]
            A[i][k] /= A[k][k];
        }
        // b[i]
        for (int i=k+1; i<n; ++i){
            b[i] -= A[i][k]*b[k];
        }
        // A[i][j]
        for (int i=k+1; i<n; ++i){
            for (int j=k+1; j<n; ++j){
                A[i][j] -= A[i][k] * A[k][j];
            }
        }
    }
    // 回代过程  
    for (int k=n-1; k>=0; --k){
        
        for (int j=k+1; j<n; ++j){
            b[k] -= A[k][j] * x[j];
        }
        x[k] = b[k] / A[k][k];
    }
    return x;
}

References

[1] 李乃成, 梅立泉. 数值分析[M]. 科学出版社, 2011.

笔者水平有限，如有错误欢迎批评指正~