网站首页 网站地图
网站首页 > 娱乐人生 > 编程时求方程的根怎么弄

编程时求方程的根怎么弄

时间:2026-03-20 14:02:31

求方程的根可以通过多种编程方法实现,包括直接使用求根公式、牛顿迭代法、二分法等。以下是几种常见编程语言的示例代码:

Python

```python

import math

def solve_quadratic(a, b, c):

discriminant = b 2 - 4 * a * c

if discriminant > 0:

root1 = (-b + math.sqrt(discriminant)) / (2 * a)

root2 = (-b - math.sqrt(discriminant)) / (2 * a)

return root1, root2

elif discriminant == 0:

root = -b / (2 * a)

return root,

else:

realPart = -b / (2 * a)

imaginaryPart = math.sqrt(-discriminant) / (2 * a)

return complex(realPart, imaginaryPart), complex(realPart, -imaginaryPart)

```

Java

```java

public class QuadraticSolver {

public static double[] solveQuadratic(double a, double b, double c) {

double discriminant = b * b - 4 * a * c;

if (discriminant > 0) {

double root1 = (-b + Math.sqrt(discriminant)) / (2 * a);

double root2 = (-b - Math.sqrt(discriminant)) / (2 * a);

return new double[]{root1, root2};

} else if (discriminant == 0) {

double root = -b / (2 * a);

return new double[]{root};

} else {

double realPart = -b / (2 * a);

double imaginaryPart = Math.sqrt(-discriminant) / (2 * a);

return new double[]{complex(realPart, imaginaryPart), complex(realPart, -imaginaryPart)};

}

}

private static class complex {

double real;

double imaginary;

complex(double real, double imaginary) {

this.real = real;

this.imaginary = imaginary;

}

@Override

public String toString() {

return real + "+" + imaginary + "i";

}

}

public static void main(String[] args) {

double[] roots = solveQuadratic(1, -3, 2);

System.out.println("Roots: " + roots + ", " + roots);

}

}

```

C++

```cpp

include

include

include

std::pair solveQuadratic(double a, double b, double c) {

double discriminant = b * b - 4 * a * c;

if (discriminant > 0) {

double root1 = (-b + std::sqrt(discriminant)) / (2 * a);

double root2 = (-b - std::sqrt(discriminant)) / (2 * a);

return {root1, root2};

} else if (discriminant == 0) {

double root = -b / (2 * a);

return {root, root};

} else {

double realPart = -b / (2 * a);

double imaginaryPart = std::sqrt(-discriminant) / (2 * a);

return {std::complex(realPart, imaginaryPart), std::complex(realPart, -imaginaryPart)};

}

}

int main() {

auto roots = solveQuadratic(1, -3, 2);

std::cout << "Roots: " << roots.first << ", " << roots.second << std::endl;

return 0;

}

```

C语言(牛顿迭代法)