高斯消元法java_Gauss消元法的原理及Java实现

本文介绍了高斯消元法的基本原理,并通过一个例子阐述其解决多元一次方程组的过程。文章指出在分母很小时可能导致数值不稳定,为此提出了列主元高斯消元法来解决这一问题。最后,给出了一个完整的Java实现,包括消元法、回代法和输出方程组解的函数。
摘要由CSDN通过智能技术生成

补充知识:

要理解Gauss消去法,首先来看一个例子:

52a5b24a20201a6b457ded52c0470674.png

从上例子可以看出,高斯消去法实际上就是我们初中学的阶二元一次方程组,只不过那里的未知数个数$n=2$

$n>2$时,Gauss消去法的思路实际上和解二元一次方程组是一样的,方法如下:

将$n$方程组中的$n-1$个方程通过消元,形成一个与原方程组等价的一个新方程组,新方程组中的$n-1$个方程仅包含$n-1$个未知数。

故问题就转化为了求解$n-1$元的方程组,这样我们可以继续消元,以次类推,直到最后一个方程组为一元一次方程组

从最后一个一元一次方程组求解出最后一个未知量,然后逐步回代入之前的方程组,从而得到所有的未知数。

我们可以看到Gauss实际上就分为两步:消去和回代

下面通过一般化得到Gauss消元法的求解过程

ba547b62f99abfa91f86ef4fe7781b38.png

738b9ce80d687edb95fc9a5eb2a62b70.png

c58724fddce395dd0df200459c0ec958.png

以上就是Gauss消去法的基本步骤,我们再回过头看看有没有什么问题?

我们在求比例$l_{ik}= \frac{a_{ik}^{\left (k-1  \right )}}{a_{kk}^{\left (k-1  \right )}}$时,如果分母很小,即:

ef1ec957e581d7711b5f5f4000c8cb16.png

$l_{ik}\rightarrow \infty$,那么

55787c974a4e9f79fe9de201a61cfc87.png

总结一下,能否使用Gauss消元法的情况

086b0707c154d064ebe4f44dd23e40fc.png

为了解决这个问题,我们可以使用列主元Gauss消元法。

17bfd73ee5b49792764800a20b156af8.png

参考了一些网上的代码,这里给出Gauss的Java实现

packagepeterxiazhe;importjava.util.Scanner;public classGauss {/*** 列主元高斯消去法*/

static doubleA[][];static doubleb[];static doublex[];static int n; //n表示未知数的个数

static int n_2; //记录换行的次数

public static voidmain(String[] args) {

System.out.println("--------------输入方程组未知数的个数---------------");

Scanner sc= newScanner(System.in);

n=sc.nextInt();

A= new double[n][n];

b= new double[n];

x= new double[n];

System.out.println("--------------输入方程组的系数矩阵A:---------------");for(int i = 0; i < n; i++) {for(int j = 0; j < n; j++) {

A[i][j]=sc.nextDouble();

}

}

System.out.println("--------------输入方程组的常量向量b:---------------");for(int i = 0; i < n; i++) {

b[i]=sc.nextDouble();

}

Elimination();

BackSubstitution();

PrintRoot();

}//消元法

public static voidElimination() {

PrintA();for(int k = 0; k < n; k++) {

WrapRow(k);for(int i = k+1; i < n; i++) {double l = A[i][k] /A[k][k];

A[i][k]= 0;for(int j = k+1; j < n; j++) {

A[i][j]= A[i][j] - l *A[k][j];

}

b[i]= b[i] - l *b[k];

}//System.out.println("第" + k + "次消元后:");//PrintA();

}

}//回代法

public static voidBackSubstitution() {

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

x[i]= (b[i] - solve(i)) /A[i][i];

}

}public static double solve(inti) {double result = 0.0;for(int j = i; j < n; j++)

result+= A[i][j] *x[j];returnresult;

}//输出方程组的根

public static voidPrintRoot() {

System.out.println("--------------方程组的根为---------------");for(int i = 0; i < n; i++) {

System.out.println("x" + (i+1) + " = " +x[i]);

}

}//交换Swap函数???

public static void Swap(double[] ar, int x, inty) {

Double tmp=ar[x];

ar[x]=ar[y];

ar[y]=tmp;

}public static void PrintA() { //输出A的增广矩阵//System.out.println("--------------增广矩阵---------------");

for(int i = 0; i < n; i++) {for(int j = 0; j < n; j++) {

System.out.print(A[i][j]+ " ");

}

System.out.println(b[i]);

}

}//交换矩阵的行

public static void WrapRow(int k) { //k表示第k+1轮消元

double maxElement =Math.abs(A[k][k]);int WrapRowIndex = k; //记住要交换的行

for(int i = k + 1; i < n; i++) {if (Math.abs(A[i][k]) >maxElement) {

WrapRowIndex=i;

maxElement=A[i][k];

}

}if (WrapRowIndex != k) { //交换求得最大主元

n_2 += 1;

System.out.println("k = " + k + "时," + "要交换的行为" + k + "和"+WrapRowIndex);//先交换A

for(int j = k; j < n; j++) {double[] arr ={A[k][j], A[WrapRowIndex][j]};

Swap(arr,0, 1);

A[k][j]= arr[0]; A[WrapRowIndex][j] = arr[1];//double tmp = A[k][j];//A[k][j] = A[WrapRowIndex][j];//A[WrapRowIndex][j] = tmp;

}//再交换b

double[] arr ={b[k], b[WrapRowIndex]};

Swap(arr,0, 1);

b[k]= arr[0]; b[WrapRowIndex] = arr[1];//double tmp = b[k];//b[k] = b[WrapRowIndex];//b[WrapRowIndex] = tmp;

System.out.println("--------------交换后---------------");

PrintA();

}

}

}

注意:由于Java不支持对基本数据类型的引用传递,这里使用了一个小技巧。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
高斯消元法是一种线性方程组求解方法,可以通过基于Java语言的编程实现。下面是基于Java实现高斯消元法的过程解析。 1. 首先,定义一个二维数组来存储线性方程组的系数矩阵和常数向量,例如: ``` double[][] coefficients = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; double[] constants = {10, 11, 12}; ``` 其中,coefficients是系数矩阵,constants是常数向量。 2. 接着,编写高斯元算法的代码。具体实现过程如下: - 首先,使用循环将系数矩阵转化为上三角矩阵。 ``` for (int i = 0; i < coefficients.length - 1; i++) { for (int j = i + 1; j < coefficients.length; j++) { double factor = coefficients[j][i] / coefficients[i][i]; for (int k = i + 1; k < coefficients.length; k++) { coefficients[j][k] -= factor * coefficients[i][k]; } constants[j] -= factor * constants[i]; } } ``` - 其次,使用循环求解线性方程组的解向量。从最后一行开始,逐行求解。 ``` double[] solutions = new double[coefficients.length]; for (int i = coefficients.length - 1; i >= 0; i--) { double sum = 0; for (int j = i + 1; j < coefficients.length; j++) { sum += coefficients[i][j] * solutions[j]; } solutions[i] = (constants[i] - sum) / coefficients[i][i]; } ``` 3. 最后,将求解得到的解向量输出。例如: ``` for (int i = 0; i < solutions.length; i++) { System.out.println("x[" + i + "] = " + solutions[i]); } ``` 这样就可以基于Java实现高斯消元法的过程解析了。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值