Gauss列主元素消去法-C++【可直接复制粘贴/欢迎评论点赞】

Gauss列主元素消去法（也称为列主元Gauss消去法）是Gauss消去法的一种改进版本，主要用于求解线性方程组。在C++中实现时，它具有一些显著的优点和缺点，并且有着深厚的数学和计算背景。

优点

1. 提高数值稳定性：列主元Gauss消去法通过在每一列中选择绝对值最大的元素作为主元，从而避免了在消元过程中使用过小或接近零的主元，这有助于提高计算的数值稳定性和精度。
2. 减少误差累积：由于选择了较大的主元进行消元，该方法能够减少因舍入误差导致的误差累积，特别是在处理大规模或条件数较大的线性方程组时尤为重要。
3. 广泛适用性：列主元Gauss消去法不仅适用于求解线性方程组，还可以应用于求解矩阵的逆、求解最小二乘问题等，具有广泛的应用领域。
4. 易于实现：尽管算法相对复杂，但C++作为一种高效的编程语言，能够很好地支持列主元Gauss消去法的实现，使得该方法在实际应用中易于部署和使用。

缺点

1. 时间复杂度较高：相比于简单的Gauss消去法，列主元Gauss消去法需要额外的步骤来寻找每一列的主元并进行行交换，这增加了算法的时间复杂度。特别是在处理大型稀疏矩阵时，这种增加可能更加显著。
2. 对矩阵排列有要求：列主元Gauss消去法的性能受到矩阵中元素排列的影响。在某些特殊情况下，如果矩阵的元素排列不利于主元的选择，可能会导致算法的效率降低。
3. 数值稳定性并非绝对：虽然列主元Gauss消去法提高了数值稳定性，但在某些极端情况下（如矩阵接近奇异），仍然可能出现数值不稳定的问题。

背景

Gauss列主元素消去法是基于Gauss消去法的一种改进。Gauss消去法是一种经典的线性方程组求解方法，它通过将线性方程组转换为增广矩阵，并通过一系列的行变换将矩阵转换为上三角形或对角形矩阵，从而简化求解过程。然而，传统的Gauss消去法在处理某些特定类型的线性方程组时，可能会因为主元过小而导致数值不稳定。为了克服这一缺点，人们提出了列主元Gauss消去法，通过在每一列中选择绝对值最大的元素作为主元，以提高算法的数值稳定性和精度。

在C++中实现Gauss列主元素消去法时，需要遵循算法的基本原理和步骤，包括选择主元、进行行交换、执行消元操作以及最后通过回代求解出未知数的值。此外，还需要注意数值精度、输入验证等问题，以确保算法的正确性和稳定性。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <iomanip>
#include <math.h>
using namespace std;


void SolverEqGauss(double **A, double *b, int n, double *x);
//其中A和b为系数矩阵，n为矩阵阶数，x为待求解变量，eps为精度。
int main()
{
    int i, n;
	double **A, *b, *x;
	//输入维数
	cin >> n;
	A = new double *[n];
	b = new double[n];
	x = new double[n];
	for (i = 0; i < n; i++)
	{
		A[i] = new double[n];
	}
	//输入系数矩阵和向量
    for (i = 0; i < n; i++) 
	{
        for (int j = 0; j < n; j++)
		{
            cin >> A[i][j];
        }
    }
    for (int i = 0; i < n; i++) 
	{
        cin >> b[i];
    }

	//计算
	SolverEqGauss(A, b, n, x);
	//输出
	for (i = 0; i < n; i++)
	{
		cout << fixed << setprecision(5) << x[i] <<" ";
	}
	delete[]b;//释放内存
	delete[]x;
	for (i = 0; i < n; i++)
	{
		delete[]A[i];
	}
	return 0;
}

 
void SolverEqGauss(double **A, double *b, int n, double *x)  
{  
    int i, j, k, maxRow;  
    double **a = new double *[n];  
    double *btemp = new double[n];  
    double d, temp, maxPivot;  
  
    for (i = 0; i < n; i++)  
    {  
        a[i] = new double[n + 1];  
    }  
  
    // 赋值  
    for (i = 0; i < n; i++)  
    {  
        for (j = 0; j < n; j++)  
        {  
            a[i][j] = A[i][j];  
        }  
        a[i][n] = b[i];  
    }  
  
    for (k = 0; k < n - 1; k++)  
    {  
        // 找列主元最大值  
        maxPivot = fabs(a[k][k]);  
        maxRow = k;  
        for (i = k + 1; i < n; i++)  
        {  
            if (fabs(a[i][k]) > maxPivot)  
            {  
                maxPivot = fabs(a[i][k]);  
                maxRow = i;  
            }  
        }  
        // 如果最大主元为0，则矩阵奇异，无法求解  
        if (maxPivot == 0)  
        {  
            cerr << "The matrix is singular, cannot solve." << endl;  
            exit(EXIT_FAILURE);  
        }  
  
        // 换行  
        if (maxRow != k)  
        {  
            for (j = k; j <= n; j++)  
            {  
                temp = a[k][j];  
                a[k][j] = a[maxRow][j];  
                a[maxRow][j] = temp;  
            }  
        }  
  
        // 消元  
        for (i = k + 1; i < n; i++)  
        {  
            d = a[i][k] / a[k][k];  
            for (j = k + 1; j <= n; j++)  
            {  
                a[i][j] -= d * a[k][j];  
            }  
        }  
    }  
  
    // 回代求解  
    for (i = n - 1; i >= 0; i--)  
    {  
        btemp[i] = a[i][n];  
        for (j = i + 1; j < n; j++)  
        {  
            btemp[i] -= a[i][j] * btemp[j];  
        }  
        btemp[i] /= a[i][i];  
    }  
  
    // 将解赋值给x  
    for (i = 0; i < n; i++)  
    {  
        x[i] = btemp[i];  
    }  
  
    // 释放内存  
    for (i = 0; i < n; i++)  
    {  
        delete[] a[i];  
    }  
    delete[] a;  
    delete[] btemp;  
}