JAVA用List实现高斯消元法

以下是JAVA用List实现高斯消元法的示例代码：

import java.util.ArrayList;
import java.util.List;

public class GaussianElimination {
    public static void main(String[] args) {
        // 系数矩阵
        List<List<Double>> matrix = new ArrayList<>();
        List<Double> row1 = new ArrayList<>();
        row1.add(2.0);
        row1.add(1.0);
        row1.add(-3.0);
        row1.add(4.0);
        List<Double> row2 = new ArrayList<>();
        row2.add(4.0);
        row2.add(-1.0);
        row2.add(2.0);
        row2.add(3.0);
        List<Double> row3 = new ArrayList<>();
        row3.add(-2.0);
        row3.add(5.0);
        row3.add(-1.0);
        row3.add(-3.0);
        matrix.add(row1);
        matrix.add(row2);
        matrix.add(row3);
        // 常数向量
        List<Double> vector = new ArrayList<>();
        vector.add(3.0);
        vector.add(9.0);
        vector.add(-5.0);
        // 高斯消元
        int n = matrix.size();
        for (int i = 0; i < n; i++) {
            // 找到第i列的最大元素
            double max = Math.abs(matrix.get(i).get(i));
            int maxIndex = i;
            for (int j = i + 1; j < n; j++) {
                double val = Math.abs(matrix.get(j).get(i));
                if (val > max) {
                    max = val;
                    maxIndex = j;
                }
            }
            // 将最大元素所在行与第i行交换
            List<Double> temp = matrix.get(i);
            matrix.set(i, matrix.get(maxIndex));
            matrix.set(maxIndex, temp);
            double tempVal = vector.get(i);
            vector.set(i, vector.get(maxIndex));
            vector.set(maxIndex, tempVal);
            // 消元
            for (int j = i + 1; j < n; j++) {
                double factor = matrix.get(j).get(i) / matrix.get(i).get(i);
                for (int k = i; k < n; k++) {
                    matrix.get(j).set(k, matrix.get(j).get(k) - factor * matrix.get(i).get(k));
                }
                vector.set(j, vector.get(j) - factor * vector.get(i));
            }
        }
        // 回代
        List<Double> solution = new ArrayList<>();
        for (int i = n - 1; i >= 0; i--) {
            double sum = 0.0;
            for (int j = i + 1; j < n; j++) {
                sum += matrix.get(i).get(j) * solution.get(n - j - 1);
            }
            double x = (vector.get(i) - sum) / matrix.get(i).get(i);
            solution.add(x);
        }
        // 输出解
        System.out.println("Solution:");
        for (int i = n - 1; i >= 0; i--) {
            System.out.println("x" + (n - i) + " = " + solution.get(i));
        }
    }
}

在上述示例代码中，我们用List来表示系数矩阵和常数向量，通过遍历List来实现高斯消元和回代。具体实现过程如下：

1. 初始化系数矩阵和常数向量。

2. 遍历系数矩阵，对于每一列，找到最大元素所在的行，并将该行与当前行交换。

3. 对于每一行，遍历该行的每一个元素，将其除以该行的第一个元素，得到一个系数因子。

4. 对于当前行的下面所有行，遍历该行的每一个元素，将其减去当前行的对应元素乘以系数因子，消去该元素。

5. 遍历常数向量，将其也按照相同的系数因子进行消元。

6. 回代求解未知数，从最后一行开始，依次计算每个未知数的值。

7. 输出解。

需要注意的是，在实现过程中，由于List是动态数组，因此我们需要使用List的add、set和get等方法来操作其中的元素。此外，由于Java的List是引用类型，因此在进行高斯消元和回代的过程中，需要注意不要改变原始的系数矩阵和常数向量，可以使用临时变量来存储中间结果。