如何基于java实现Gauss消元法过程解析

 更新时间:2020年10月13日 08:34:50   投稿:yaominghui  
这篇文章主要介绍了如何基于java实现Gauss消元法过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

补充知识:

正定矩阵

奇异矩阵

严格对角占优

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

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

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

  • 将n方程组中的n−1个方程通过消元,形成一个与原方程组等价的一个新方程组,新方程组中的n−1个方程仅包含n−1个未知数。
  • 故问题就转化为了求解n−1元的方程组,这样我们可以继续消元,以次类推,直到最后一个方程组为一元一次方程组
  • 从最后一个一元一次方程组求解出最后一个未知量,然后逐步回代入之前的方程组,从而得到所有的未知数。
  • 我们可以看到Gauss实际上就分为两步:消去和回代

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

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

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

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

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

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

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

package peterxiazhe;

import java.util.Scanner;

public class Gauss {
  /**
   * 列主元高斯消去法
   */
  static double A[][];
  static double b[];
  static double x[];
  
  static int n;  //n表示未知数的个数
  static int n_2;  //记录换行的次数
  
  public static void main(String[] args) {
    System.out.println("--------------输入方程组未知数的个数---------------");
    Scanner sc = new Scanner(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 void Elimination() {
    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 void  BackSubstitution() {
    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(int i) {
    double result = 0.0;
    for(int j = i; j < n; j++)
      result += A[i][j] * x[j];
    return result;
  }
  
  
  //输出方程组的根
  public static void PrintRoot() {
    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, int y) {
    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不支持对基本数据类型的引用传递,这里使用了一个小技巧

java中交换两个基本数据类型的变量函数swap(int[] source,int i,int j)

java中函数的参数传递机制是:基本数据类型采用值传递,对象采用传引用。因此,如果要写一个交换两个int型变量数值的函数,还真是有点不方便,必须采用一个数组对象来作为辅助,具体实现如下:

//交换两个整数
  private static void swap(int[] source, int i, int j) {

    int temp = source[i];
    source[i] = source[j];
    source[j] = temp;
  }

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

相关文章

  • Java 导出 CSV 文件操作详情

    Java 导出 CSV 文件操作详情

    这篇文章主要介绍了Java导出CSV文件操作详情,文章通过导入坐标展开详细内容介绍,具有一定的参考价值,需要的小伙伴可以参考一下
    2022-08-08
  • Java虚拟机JVM栈溢出的问题解决

    Java虚拟机JVM栈溢出的问题解决

    Java虚拟机栈溢出是指在Java程序中,当线程调用的方法层级过深,导致栈空间溢出的情况,本文就详细的介绍了下产生的原因以及优化,具有一定的参考价值,感兴趣的可以了解一下
    2023-08-08
  • Java HashSet集合存储遍历学生对象代码实例

    Java HashSet集合存储遍历学生对象代码实例

    这篇文章主要介绍了Java HashSet集合存储遍历学生对象代码实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2020-04-04
  • java生成xml格式文件的方法

    java生成xml格式文件的方法

    这篇文章主要介绍了java生成xml格式文件的方法,涉及java节点遍历与属性操作的相关技巧,具有一定参考借鉴价值,需要的朋友可以参考下
    2016-07-07
  • Java 中导入excel时使用 trim() 无法去除空格的问题解决方案

    Java 中导入excel时使用 trim() 无法去除空格的问题解决方案

    这篇文章主要介绍了Java中导入excel时使用trim()无法去除空格的解决方法,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2023-06-06
  • 详解Java Proxy动态代理机制

    详解Java Proxy动态代理机制

    今天给大家带来的是关于Java的相关知识,文章围绕着Java动态代理机制展开,文中有非常详细的介绍及代码示例,需要的朋友可以参考下
    2021-06-06
  • 如何使用JDBC实现工具类抽取

    如何使用JDBC实现工具类抽取

    这篇文章主要介绍了如何使用JDBC实现工具类抽取,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2020-02-02
  • RocketMQ事务消息机制详解

    RocketMQ事务消息机制详解

    这篇文章主要介绍了RocketMQ事务消息机制详解,RocketMQ服务端将消息持久化之后,向发送方返回Ack确认消息已经发送成功,由于消息为半事务消息,在未收到生产者对该消息的二次确认前,此消息被标记成"暂不能投递"状态,需要的朋友可以参考下
    2024-01-01
  • JAVA中调用C语言函数的实现方式

    JAVA中调用C语言函数的实现方式

    这篇文章主要介绍了JAVA中调用C语言函数的实现方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
    2023-08-08
  • springboot整合token的实现代码

    springboot整合token的实现代码

    这篇文章主要介绍了springboot整合token的实现代码,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2019-11-11

最新评论