java实现高斯消去法

import java.util.Scanner;

public class GaoSi {
    /**
     * 列主元下斯消来法
     */
    static double A[][];
    static double b[];
    static double x[];

    static int n;  //n暗示未知数的个数
    static int n_二;  //忘录换止的次数

    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+一; i < n; i++) {
                double l = A[i][k] / A[k][k];
                A[i][k] = 0;

                for(int j = k+一; 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⑴] = b[n⑴] / A[n⑴][n⑴];
        for(int i = n - 二; 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+一) + " = " + 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+一轮消元
        double maxElement = Math.abs(A[k][k]);

        int WrapRowIndex = k;  //  忘住要互换的止
        for(int i = k + 一; i < n; i++) {
            if (Math.abs(A[i][k]) > maxElement) {
                WrapRowIndex = i;
                maxElement = A[i][k];
            }
        }
        if (WrapRowIndex != k) {  //互换供失最年夜主元
            n_二 += 一;
            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, 一);
                A[k][j] = arr[0]; A[WrapRowIndex][j] = arr[一];
//        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, 一);
            b[k] = arr[0]; b[WrapRowIndex] = arr[一];
//      double tmp = b[k];
//      b[k] = b[WrapRowIndex];
//      b[WrapRowIndex] = tmp;
            System.out.println("--------------互换后---------------");
            PrintA();
        }
    }
}

转自：https://www.cnblogs.com/ngstx/p/15362825.html

更多文章请关注《万象专栏》