对分法求非线性方程的根

对于非线性方程的求解，有时候很难找到解的解析函数，所以只能才用数值求解。常见的一些非线性方程为

算法的基本原理：如果非线性方程f（x）=0，的左端函数f（x）在区间[a，b]上连续，并满足f（a）f（b）<0，则方程至少有一个实根。
基本思想：逐步缩小这个有根的区间，当这个区间减少到一定程序时，就取这个中点作为根的近似值。

如果在区间[a,b]内有多个实根，则单独利用对分法只能得到其一个实根。所以，将对分法与逐步扫描法结合使用，以便尽量搜索给定区间的实根，这种方法概括如下：
（1）从区间左端点x=a开始，以h为步长，逐步往后进行搜索。
（2）对于在搜索过程中遇到的每一个子区间[xk,xk+1], 其中，xk+1=xk+h。进行如下处理：
1.若f（xk）=0，则xk为一个实根，从xk+0.5h开始往后搜索
2.容易f（xk+1）=0，则xk+1为一个实根，从xk+1+0.5h开始搜索
3.若f（xk）f（xk+1）>0，则子区间无实根或h选的过大，放弃本子区间，从xk+1开始搜索
4.容易f（xk）f（xk+1）<0，则当前区间有实根，继续利用对分法，直到求到一个实根为止。，然后从
xk+1开始往后搜索。

代码如下：

/*二分法搜索方程的实根*函数int dhrt(double a,double b,double h,double eps,double *x,int m,double (*f)(double))*double a:求根区间的左端点*double b:求根区间的右端点*double h:搜索求根时所采用的步长*double eps:控制的精度要求*double* x:返回在区间[a，b]搜索到的实根。实根个数由函数值返回*int m:在区间[a,b]内实根个数的预估值*double  (*f)(double)：f（x）的迭代函数*/#include <iostream>#include<cmath>#include<iomanip>using namespace std;int dhrt(double a, double b, double h, double  eps, double *x, int m, double(*f)(double)){    int n = 0;    int js = 0;    double z = a;                                //搜素区间的中间点    double z1;                                  //定义的搜素区间的末端    double z0;                                   //定义的搜素区间的起始端    double y1;                                    //用于存放z1点的函数结果    double y0;                                   //用于存放z0点的函数结果    double y = (*f)(z);                           //用于存放函数z点处的函数结果                                                  //计算过程    while ((z <= b + h / 2) && (n != m))    {        if (fabs(y)<eps)                        //如果值满足“精度要求eps“下的0状态        {            n = n + 1;                             //进行下一次查找            x[n - 1] = z;                          //保存节点值            z = z + h / 2.0;                         //变换起始区间加0.5h继续搜素            y = (*f)(z);                         //计算中点处的值        }        else                                    //当中点处的值不满足精度要求的根时        {            z1 = z + h;                             //z1是搜素的子尾区间点            y1 = (*f)(z1);                        //计算子尾点区间的值            if (fabs(y1)<eps)                      //如果子尾区间点的值正好满足精度要求            {                n = n + 1;                             //则同上，保存根                x[n - 1] = z;                z = z1 + h / 2.0;                          //子区间起始点加0.5h                y = (*f)(z);            }            else if (y*y1>0.0)                        //首尾根节点的函数值为正，则表示无根，所以往后开始搜素            {                y = y1;                z = z1;            }            else                                       //如果有根，则二分查找            {                js = 0;                while (js == 0)                             //立一个flag                {                    if (fabs(z1 - z)<eps)                    //如果(z1-z)满足精度要求                    {                        n = n + 1;                        x[n - 1] = (z1 + z) / 2.0;                        z = z1 + h / 2.0;                           //搜素起始区间加h                        y = (*f)(z);                        js = 1;                               //flag为1                    }                    else                                   //如果不满足判断要求，继续二分                    {                        z0 = (z1 + z) / 2.0;                      //计算中点处的值                        y0 = (*f)(z0);                        if (fabs(y0)<eps)                    //满足精度要求就保存，同上                        {                            x[n] = z0;                            n = n + 1;                            js = 1;                            z = z0 + h / 2;                            y = (*f)(z);                        }                        else if (y*y0<0.0)                      //相异有根                        {                            z1 = z0;                            y1 = y0;                        }                        else                                //否则相同无根                        {                            z = z0;                            y = y0;                        }                    }                }            }        }    }    return n;}double func(double x){    return x*x - 3 * x + 2 - exp(x);}int main(){    cout << "Hello world!" << endl;    double a[5];    int n;    n = dhrt(0, 1, 0.05, 0.0000001, a, 2, func);    cout << n << endl;    cout << setprecision(8) << a[0] << "   " << endl;    return 0;}

注意一点：函数指针那个子程序是对应着不同的函数，需要自己定制！！