Java显示列主元高斯消元法的过程

以下是Java实现列主元高斯消元法的过程：

public class GaussianElimination {

    public static void main(String[] args) {
        double[][] A = {{1, 2, -1}, {2, -1, 1}, {3, 1, -2}}; // 系数矩阵
        double[] b = {2, 3, -1}; // 常数向量
        double[] x = gaussianElimination(A, b); // 解向量
        System.out.println(Arrays.toString(x)); // 输出解向量
    }

    // 列主元高斯消元法
    public static double[] gaussianElimination(double[][] A, double[] b) {
        int n = A.length; // 方程组的个数
        double[] x = new double[n]; // 解向量
        int[] idx = new int[n]; // 记录原始行号
        for (int i = 0; i < n; i++) {
            idx[i] = i;
        }
        for (int k = 0; k < n - 1; k++) {
            // 找到主元所在的行号和列号
            int p = k;
            int q = k;
            double max = Math.abs(A[k][k]);
            for (int i = k; i < n; i++) {
                for (int j = k; j < n; j++) {
                    if (Math.abs(A[i][j]) > max) {
                        max = Math.abs(A[i][j]);
                        p = i;
                        q = j;
                    }
                }
            }
            // 交换行和列
            if (p != k) {
                swapRows(A, b, k, p);
                swap(idx, k, p);
            }
            if (q != k) {
                swapColumns(A, k, q);
                swap(idx, k, q);
            }
            // 消元
            for (int i = k + 1; i < n; i++) {
                double factor = A[i][k] / A[k][k];
                b[i] -= factor * b[k];
                for (int j = k; j < n; j++) {
                    A[i][j] -= factor * A[k][j];
                }
            }
        }
        // 回带求解
        for (int i = n - 1; i >= 0; i--) {
            double sum = 0;
            for (int j = i + 1; j < n; j++) {
                sum += A[i][j] * x[j];
            }
            x[i] = (b[i] - sum) / A[i][i];
        }
        // 恢复原始顺序
        double[] y = new double[n];
        for (int i = 0; i < n; i++) {
            y[idx[i]] = x[i];
        }
        return y;
    }

    // 交换行
    private static void swapRows(double[][] A, double[] b, int i, int j) {
        double[] tempA = A[i];
        A[i] = A[j];
        A[j] = tempA;
        double tempB = b[i];
        b[i] = b[j];
        b[j] = tempB;
    }

    // 交换列
    private static void swapColumns(double[][] A, int i, int j) {
        for (int k = 0; k < A.length; k++) {
            double temp = A[k][i];
            A[k][i] = A[k][j];
            A[k][j] = temp;
        }
    }

    // 交换元素
    private static void swap(int[] a, int i, int j) {
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

该程序实现了列主元高斯消元法，其中`gaussianElimination`方法用于求解线性方程组，`swapRows`方法用于交换矩阵的行，`swapColumns`方法用于交换矩阵的列，`swap`方法用于交换数组中的元素。