多项式除法while循环中!r.hasElements()条件是否可满足？求解析

这是学院作业里的内容，我学习时发现，在实现「多项式除法」的代码中使用了!r.hasElements()这个条件，但按我对代码的理解，这个条件似乎永远无法满足，想请大家解惑。相关Java代码如下：

public class Polynomial {

    private int[] coefficients;

    private int power;

    public Polynomial(int a, int b) {
        coefficients = new int[b + 1];
        coefficients[b] = a; /* 常数项a被放置在最后一个索引位置 */
        power = Power();
    }

    public Polynomial(Polynomial p) {
        coefficients = new int[p.coefficients.length];
        for (int i = 0; i < p.coefficients.length; i++) {
            coefficients[i] = p.coefficients[i];
        }
        power = p.Power();
    }

    public int Power() {
        int d = 0;
        for (int i = 0; i < this.coefficients.length; i++) {
            if (coefficients[i] != 0) {
                d = i;
            }
        }
        return d;
    }

    public Polynomial add(Polynomial b) {
        Polynomial a = this;
        Polynomial c = new Polynomial(0, Math.max(a.power, b.power));
        for (int i = 0; i <= a.power; i++) {
            c.coefficients[i] += a.coefficients[i];
        }
        for (int i = 0; i <= b.power; i++) {
            c.coefficients[i] += b.coefficients[i];
        }
        c.power = c.Power();
        return c;
    }

    public Polynomial subtract(Polynomial b) {
        Polynomial a = this;
        Polynomial c = new Polynomial(0, Math.max(a.power, b.power));
        for (int i = 0; i <= a.power; i++) {
            c.coefficients[i] += a.coefficients[i];
        }
        for (int i = 0; i <= b.power; i++) {
            c.coefficients[i] -= b.coefficients[i];
        }
        c.power = c.Power();
        return c;
    }

    public Polynomial multiple(Polynomial b) {
        Polynomial a = this;
        Polynomial c = new Polynomial(0, a.power + b.power);
        for (int i = 0; i <= a.power; i++) {
            for (int j = 0; j <= b.power; j++) {
                c.coefficients[i + j] += (a.coefficients[i] * b.coefficients[j]);
            }
        }
        c.power = c.Power();
        return c;
    }

    public int coefficient() {
        return coefficient(Power());
    }

    public int coefficient(int power) {
        if (power > this.Power()) {
            throw new RuntimeException("Error in degree");
        }
        return coefficients[power];
    }

/* 若有人理解教授为何重载该方法名称，我不清楚其作用 */

    public Polynomial[] divide(Polynomial b) {
        Polynomial q = new Polynomial(0, 0);
        Polynomial r = new Polynomial(this);

        while (!r.hasElements() && r.Power() >= b.Power()) { // 我的疑问点
            int coefficients = r.coefficient() / b.coefficient();
            int power = r.Power() - b.Power();
            Polynomial t = new Polynomial(coefficients, power);
            q = q.add(t);
            r = r.subtract(t.multiple(b));
        }

        System.out.printf("(%s) / (%s): %s, %s", this, b, q, r);
        return new Polynomial[]{q, r};
    }

    public boolean hasElements() {              // 检查coefficients数组中是否存在非零元素
        for (int i : coefficients) {
            if (i != 0) {
                return true;
            }
        }
        return false;
    }

    @Override
    // 此处省略toString等重载方法，补充示例实现以便理解
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (int i = power; i >= 0; i--) {
            if (coefficients[i] != 0) {
                if (sb.length() > 0 && coefficients[i] > 0) sb.append("+");
                sb.append(coefficients[i]);
                if (i > 0) sb.append("x^").append(i);
            }
        }
        return sb.length() == 0 ? "0" : sb.toString();
    }
}

问题解析 #

1. hasElements()方法的实际作用：该方法遍历系数数组，只要存在非零元素就返回true（表示当前是有效多项式），否则返回false（表示当前是零多项式）。
2. 原条件的逻辑错误：
   循环条件!r.hasElements() && r.Power() >= b.Power()的含义是「r是零多项式 且 r的次数大于等于除数b的次数」。但零多项式的Power()方法会返回0（因为Power()初始化d=0，遍历全零数组后没有更新d的值）：
   • 如果除数b是常数非零多项式（次数为0），此时条件0 >= 0成立，但进入循环后，r.coefficient()返回0，除以b的系数得到0，构造的t是零多项式，后续操作不会改变q和r，会陷入死循环；
   • 如果除数b的次数大于0，零多项式的次数0小于b的次数，条件直接不满足，循环根本不会执行。
     这就是你觉得该条件永远无法满足的核心原因——它的逻辑完全不符合多项式除法的需求。
3. 正确的循环条件：
   多项式除法的循环逻辑是：当余数r不是零多项式，且r的次数大于等于除数b的次数时，继续执行除法步骤。所以正确的条件应该是r.hasElements() && r.Power() >= b.Power()，原代码把!r.hasElements()写反了。

补充：关于coefficient()重载的作用 #

无参的coefficient()方法是为了简化获取最高次项系数的操作，本质是调用coefficient(Power())，这样在除法逻辑中不需要每次手动传入r.Power()，属于合理的重载设计，能让代码更简洁。

内容的提问来源于stack exchange，提问作者user22270990