字节校招生自曝：每天仅洗数据，年薪 180万…先收了一波月发几万的期权，最近又补了一笔豆包期权～

先把事儿说清楚哈：这题叫“求解方程”，一般面试或者笔试里，八成指的是这种：

一元二次方程：ax² + bx + c = 0，已知 a、b、c，求 x 的解。

当然还可以扩展到一元一次、多元线性方程组，但先把这个最常见的整明白，思路其实都差不多。

先回顾下数学公式（轻松版）

高中那套你肯定见过：

• 先算判别式：Δ = b² - 4ac
• 如果 Δ > 0，有两个不相等的实根
• 如果 Δ = 0，有一个实根（其实是两个相等的）
• 如果 Δ < 0，没实数解（有复数解，但一般算法题不要求）

根的公式就是：

• x₁ = (-b + √Δ) / (2a)
• x₂ = (-b - √Δ) / (2a)

算法里干的事，说白了就是：把 a、b、c 读进来 → 算 Δ → 分情况返回不同的结果。

Java 里怎么写比较靠谱

先来一段最常见、也最容易让人看懂的实现（只考虑实数解）：

publicclassQuadraticSolver{

// 返回值用一个简单的结果对象，既能放状态又能放解
publicstaticclassResult{
publicint rootCount;   // 0：无实根  1：一个实根  2：两个实根  -1：不是二次方程
publicdouble x1;
publicdouble x2;
public String message;
    }

publicstatic Result solve(double a, double b, double c){
        Result result = new Result();

// 1. 先判断是不是二次方程
if (Math.abs(a) < 1e-8) {  // a ≈ 0 的时候，其实就是一元一次：bx + c = 0
if (Math.abs(b) < 1e-8) {
// a 和 b 都接近 0，就看 c：
//   c 也接近 0：0x = 0，无穷多解
//   否则：0x = c，无解
                result.rootCount = -1;
                result.message = "不是合法的一元二次或一元一次方程";
            } else {
// bx + c = 0 => x = -c / b
                result.rootCount = 1;
                result.x1 = -c / b;
                result.message = "退化为一元一次方程";
            }
return result;
        }

// 2. 正常二次方程，先算判别式
double delta = b * b - 4 * a * c;

if (delta > 0) {
double sqrtDelta = Math.sqrt(delta);
            result.x1 = (-b + sqrtDelta) / (2 * a);
            result.x2 = (-b - sqrtDelta) / (2 * a);
            result.rootCount = 2;
            result.message = "有两个不相等的实根";
        } elseif (Math.abs(delta) < 1e-8) {
// 判别式接近 0，当成一个实根处理
double x = -b / (2 * a);
            result.x1 = x;
            result.x2 = x;
            result.rootCount = 1;
            result.message = "有两个相等的实根（重根）";
        } else {
            result.rootCount = 0;
            result.message = "无实数解";
        }
return result;
    }

publicstaticvoidmain(String[] args){
        Result r = solve(1, -3, 2); // x^2 - 3x + 2 = 0
        System.out.println("rootCount = " + r.rootCount);
        System.out.println("message   = " + r.message);
if (r.rootCount > 0) {
            System.out.println("x1 = " + r.x1);
        }
if (r.rootCount > 1) {
            System.out.println("x2 = " + r.x2);
        }
    }
}

这段代码里面，有几个小点可以顺带记一下：

1. 尽量别直接用 a == 0 这种判断浮点数有精度，Math.abs(a) < 1e-8 这种写法更稳一点，相当于“足够接近 0 就算 0”。

2. 一元二次退化的一元一次要顺手处理很多题会卡这个边界，比如 a 传 0，或者很小的数，你要么直接报错，要么优雅地当一元一次方程来解，两种都可以，只要说明白。

3. 判别式为 0 的时候记得别写成两个分支delta == 0 时，两个根是一样的，算法里可以只算一次，结果赋给 x1、x2 就行了，方便调用方统一处理。

如果要更通用一点还能怎么扩展？

• 想支持复数解的话，可以在 delta < 0 的分支里，拆成实部和虚部，自己搞一个 Complex 类。
• 想支持方程组，比如两元一次方程组，就会用到行列式、消元或者矩阵求解，代码结构会更复杂一些，但“先在数学上有公式 → 再翻译成 Java”的套路是一样的。
• 想避免浮点误差特别夸张的场景（比如金融类计算），可以用 BigDecimal 来存系数和解，不过写法就没这么清爽了，主要就是 add / subtract / multiply / divide 这些方法连起来用。

整体看下来，其实“求解方程”这类算法题，本质就是三步：搞清楚数学模型 → 分清边界情况 → 翻译成代码并处理好精度和异常输入。 只要这条线捋顺了，换别的方程类型，你也能很快写出对应的 Java 版本。