JAVA用List实现高斯消元法

高斯消元法是一种线性方程组求解的方法，可以用JAVA中的List实现。具体实现步骤如下：

1. 定义一个二维List作为系数矩阵，同时定义一个一维List作为常数向量。

2. 实现高斯消元的主要代码，包括将系数矩阵化为上三角矩阵、回带求解等。

3. 在主函数中输入系数矩阵和常数向量，并调用高斯消元方法求解线性方程组。

以下是JAVA代码实现：

import java.util.*;

public class GaussElimination {
    public static void main(String[] args) {
        // 输入系数矩阵和常数向量
        Scanner input = new Scanner(System.in);
        System.out.println("请输入系数矩阵的行数和列数：");
        int m = input.nextInt();
        int n = input.nextInt();
        List<List<Double>> A = new ArrayList<List<Double>>();
        System.out.println("请输入系数矩阵：");
        for (int i = 0; i < m; i++) {
            List<Double> row = new ArrayList<Double>();
            for (int j = 0; j < n; j++) {
                row.add(input.nextDouble());
            }
            A.add(row);
        }
        System.out.println("请输入常数向量：");
        List<Double> B = new ArrayList<Double>();
        for (int i = 0; i < m; i++) {
            B.add(input.nextDouble());
        }

        // 高斯消元求解线性方程组
        List<Double> X = gaussElimination(A, B);

        // 输出解向量
        System.out.println("解向量为：");
        for (int i = 0; i < X.size(); i++) {
            System.out.print(X.get(i) + " ");
        }
        System.out.println();
    }

    // 高斯消元求解线性方程组
    public static List<Double> gaussElimination(List<List<Double>> A, List<Double> B) {
        int n = A.size();
        for (int k = 0; k < n; k++) {
            // 找到主元素所在行
            int maxRow = k;
            double maxVal = Math.abs(A.get(k).get(k));
            for (int i = k + 1; i < n; i++) {
                double val = Math.abs(A.get(i).get(k));
                if (val > maxVal) {
                    maxRow = i;
                    maxVal = val;
                }
            }
            // 交换行
            if (maxRow != k) {
                List<Double> tmp = A.get(k);
                A.set(k, A.get(maxRow));
                A.set(maxRow, tmp);
                double tmpB = B.get(k);
                B.set(k, B.get(maxRow));
                B.set(maxRow, tmpB);
            }
            // 消元
            for (int i = k + 1; i < n; i++) {
                double factor = A.get(i).get(k) / A.get(k).get(k);
                for (int j = k + 1; j < n; j++) {
                    A.get(i).set(j, A.get(i).get(j) - factor * A.get(k).get(j));
                }
                B.set(i, B.get(i) - factor * B.get(k));
            }
        }
        // 回带求解
        List<Double> X = new ArrayList<Double>();
        for (int i = n - 1; i >= 0; i--) {
            double sum = 0.0;
            for (int j = i + 1; j < n; j++) {
                sum += A.get(i).get(j) * X.get(n - j - 1);
            }
            X.add((B.get(i) - sum) / A.get(i).get(i));
        }
        // 翻转解向量
        Collections.reverse(X);
        return X;
    }
}