如何在Java中高效实现多项式加法

import java.util.Arrays;

public class PolynomialOperations {

    /**
     * 将两个多项式相加。
     * 多项式由系数数组表示，其中 array[i] 是 x^i 的系数。
     *
     * @param poly1 第一个多项式的系数数组。
     * @param poly2 第二个多项式的系数数组。
     * @return 表示两个多项式之和的新系数数组。
     */
    public static double[] addPolynomials(double[] poly1, double[] poly2) {
        // 确定结果多项式的最大长度
        int maxLength = Math.max(poly1.length, poly2.length);
        double[] result = new double[maxLength];

        // 遍历并相加对应幂次的系数
        for (int i = 0; i < maxLength; i++) {
            double coeff1 = (i < poly1.length) ? poly1[i] : 0.0;
            double coeff2 = (i < poly2.length) ? poly2[i] : 0.0;
            result[i] = coeff1 + coeff2;
        }

        // 移除结果数组末尾的零（可选，使表示更紧凑）
        return trimZeros(result);
    }

    /**
     * 移除多项式系数数组末尾的零，除非多项式本身为零。
     *
     * @param polynomial 系数数组。
     * @return 移除末尾零后的新系数数组。
     */
    private static double[] trimZeros(double[] polynomial) {
        int lastNonZero = polynomial.length - 1;
        while (lastNonZero > 0 && polynomial[lastNonZero] == 0.0) {
            lastNonZero--;
        }
        // 如果所有系数都是0，则返回一个包含单个0的数组
        if (lastNonZero == 0 && polynomial[0] == 0.0) {
            return new double[]{0.0};
        }
        return Arrays.copyOf(polynomial, lastNonZero + 1);
    }

    /**
     * 将系数数组格式化为可读的多项式字符串。
     *
     * @param polynomial 系数数组。
     * @return 多项式字符串表示。
     */
    public static String formatPolynomial(double[] polynomial) {
        if (polynomial == null || polynomial.length == 0) {
            return "0";
        }

        StringBuilder sb = new StringBuilder();
        boolean firstTerm = true;

        // 从最高次项开始遍历，以便输出更自然
        for (int i = polynomial.length - 1; i >= 0; i--) {
            double coeff = polynomial[i];

            if (coeff == 0.0) {
                continue; // 跳过零系数项
            }

            if (!firstTerm) {
                sb.append(coeff > 0 ? " + " : " - ");
            } else {
                if (coeff < 0) {
                    sb.append("-");
                }
            }

            double absCoeff = Math.abs(coeff);

            if (i == 0) { // 常数项
                sb.append(String.format("%.1f", absCoeff));
            } else if (i == 1) { // x^1 项
                if (absCoeff != 1.0) { // 系数不为1时才显示
                    sb.append(String.format("%.1f", absCoeff));
                }
                sb.append("x");
            } else { // x^i (i > 1) 项
                if (absCoeff != 1.0) { // 系数不为1时才显示
                    sb.append(String.format("%.1f", absCoeff));
                }
                sb.append("x^").append(i);
            }
            firstTerm = false;
        }

        if (sb.length() == 0) {
            return "0"; // 如果所有项都为零
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        // 原始问题中的多项式：
        // poly1 = "2x^3 + 3x^2 + 2";  -> {2 (x^0), 0 (x^1), 3 (x^2), 2 (x^3)}
        // poly2 = "2x^2 + 6";        -> {6 (x^0), 0 (x^1), 2 (x^2)}

        double[] poly1 = {2.0, 0.0, 3.0, 2.0}; // 2x^3 + 3x^2 + 2
        double[] poly2 = {6.0, 0.0, 2.0};      // 2x^2 + 6

        System.out.println("多项式1: " + formatPolynomial(poly1));
        System.out.println("多项式2: " + formatPolynomial(poly2));

        double[] sumPoly = addPolynomials(poly1, poly2);
        System.out.println("它们的和: " + formatPolynomial(sumPoly)); // 预期: 2x^3 + 5x^2 + 8.0

        // 另一个示例
        double[] pA = {1.0, -2.0, 3.0}; // 3x^2 - 2x + 1
        double[] pB = {5.0, 2.0};       // 2x + 5
        System.out.println("\n多项式A: " + formatPolynomial(pA));
        System.out.println("多项式B: " + formatPolynomial(pB));
        double[] sumAB = addPolynomials(pA, pB);
        System.out.println("它们的和: " + formatPolynomial(sumAB)); // 预期: 3x^2 + 6.0
    }
}

多项式1: 2.0x^3 + 3.0x^2 + 2.0
多项式2: 2.0x^2 + 6.0
它们的和: 2.0x^3 + 5.0x^2 + 8.0

多项式A: 3.0x^2 - 2.0x + 1.0
多项式B: 2.0x + 5.0
它们的和: 3.0x^2 + 6.0