java实现解一元n次多项式(二)

最新推荐文章于 2024-09-10 17:01:47 发布

竖琴手

最新推荐文章于 2024-09-10 17:01:47 发布

阅读量2.7k

点赞数 2

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/strangerzz/article/details/45647745

针对之前解一元n次多项式代码效率问题，本文提供了优化方案，去除了数组赋值和增广矩阵生成，以提高运行效率。详细改进思路可参阅作者前文。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

package commonAlgorithm;

public class PolynomialSoluter {
    private double[][] matrix;
    private double[] result;
    private int order;

    // public PolynomialSoluter() {
    //
    // }

    // 检查输入项长度
    private boolean init(double[][] matrixA, double[] arrayB) {
        order = arrayB.length;
        if (matrixA.length != order)
            return false;
        for (double[] arrayA : matrixA)
            if (arrayA.length != order)
                return false;
        matrix = matrixA;
        result = arrayB;
        return true;
    }

    public double[] getResult(double[][] matrixA, double[] arrayB) {
        if (!init(matrixA, arrayB))
            return null;
        // 高斯消元-正向
        for (int i = 0; i < order; i++) {
            // 如果当前行对角线项为0则与后面的同列项非0的行交换
            if (!swithIfZero(i))
                return null;
            // 消元
            for (int j = i + 1; j < order; j++) {
                if (matrix[j][i] == 0)
                    continue;
                double factor = matrix[j][i] / matrix[i][i];
                for (int l = i; l < order; l++)
                    matrix[j][l] -= matrix[i][l] * factor;
                result[j] -= result[i] * factor;
            }
        }
        // 高斯消元-反向-去掉了冗余计算
        for (int i = order - 1; i >= 0; i--) {
            result[i] /= matrix[i][i];
            for (int j = i - 1; j > -1; j--)
                result[j] -= result[i] * matrix[j][i];
        }
        return result.clone();
    }

    private boolean swithIfZero(int i) {
        if (matrix[i][i] == 0) {
            int j = i + 1;
            // 找到对应位置非0的列
            while (j < order && matrix[j][i] == 0)
                j++;
            // 若对应位置全为0则无解
            if (j == order)
                return false;
            else
                switchRows(i, j);
        }
        return true;
    }

    // 调换行
    private void switchRows(int i, int j) {
        double[] tmp1 = matrix[i];
        matrix[i] = matrix[j];
        matrix[j] = tmp1;
        double tmp2 = result[i];
        result[i] = result[j];
        result[j] = tmp2;
    }

    public static void main(String[] args) {
        double[][] matrixA = { { 0, 0, 1 }, { 0, 1, 0 }, { 1, 0, 0 } };
        double[] arrayB = { 1, 3, 2 };
        PolynomialSoluter ps = new PolynomialSoluter();
        for (double result : ps.getResult(matrixA, arrayB))
            System.out.println(result);
    }
}

后来发现这个类要被调用太多次，但之前没考虑效率问题。所以重新写了这个类，之前的代码参考我之前的文章http://blog.youkuaiyun.com/strangerzz/article/details/45244249
主要就是去掉了数组里面赋值等操作，也不再生成增广矩阵了。虽然看起来比以前要难理解一下，但是效率应该会有所提升