package 实验一;
public class Test2 { static double x0; // 二分次数 public static double f(int x) {
return x * x * x + x * x - 3 * x - 3;
}


public static double fDerivative(int x){      //导数表达式
return 3*x*x+2*x-3;
}


public static double x(int n){                //递归求Xn
if(n==0){
return x0;
}else{
return x(n-1)-f(n-1)/fDerivative(n-1);
}
}

public static double newton(double x0, double eps,int n) {


int k=1;
while(Math.abs(x(k)-x(k-1))>eps){
k++;
}

if(k>n){
return 0;
}else{
return x(k);
}

} public static void main(String[] args) {


System.out.print("请输入初始值X0:");
x0=KB.scanDouble();
System.out.print("\n请输入根的容许误差限EPS的值:");
double EPS = KB.scanDouble();
System.out.print("\n请输入迭代次数N:");
int n=(int) KB.scanInt();
newton(x0,EPS,n);
if (newton(x0, EPS, n) != 0) {
System.out.println(newton(x0, EPS, n));
}else{
System.out.println("算法失败!");
}
    
}}import java.util.Scanner;
class KB {

public static int scanInt(){   //接收数值型输入 
  Scanner in=new Scanner(System.in); 
      int a=in.nextInt();
      return a;
  }  public static double scanDouble() { // 接收数值输入
Scanner in = new Scanner(System.in);
double a=in.nextDouble();
return a; 
}
}这是数值计算 牛顿迭代法的程序!!麻烦给看看哪里错了!!
牛顿迭代法思想如下:f'(x)为多项式f(x)的导数表达式!
当X(k)-X(k-1)<EPS时,迭代结束!!
X(k)就是多项式的根!!
递归迭代Java堆栈溢出

解决方案 »

  1.   

    艾玛快要下班了,晚上再研究。不过初步看来是你在这里:
    while (Math.abs(x(k) - x(k - 1)) > eps) {
    在一个循环内用了k++,但是到了x这个函数里:
    return x(n - 1) - f(n - 1) / fDerivative(n - 1);
    又进行了x(n-1)的调用,所以结果是当你k=1的时候,调用了x(1),x(0);k=2的时候调用了x(2), x(1), x(0)。k的值是多少,就有多少次递归调用,这个大概是让你stack爆炸的原因。你把 if (k>n) return 0这个放到while里面就行了
      

  2.   


    程序循环结束条件是|x(k)-x(k-1)|<EPS
    x(k)就是得到的根!
    不循环计算K,怎么得到K的值
      

  3.   

    你的目的不是得到x的值么?跟k有什么关系
    你再仔细看看流程图里面的k是干啥用的
    牛顿迭代法就是拿前一个x来生成后一个x,去逼近根的值,k只是表示这样的过程重复几次,而N就是限制重复的次数。
    x(10) - x(9) < EPS是你的条件,x( x(9) ) - x (9) < EPS 则是牛顿的意思
      

  4.   


    可是你不知道迭代多少次  例如想x(k)是多项式的根,不算出k的值,怎么得到x(k)
      

  5.   

    啊,我明白你的x是什么意思了,你把k当成下标,然后用x(k)来算的是x下标k的值容我再考虑一下
      

  6.   

      public static double x(int n) {                //递归求Xn
        if (n == 0) {
          return x0;
        }
        else {
          return x(n - 1) - f(x(n - 1)) / fDerivative(x(n - 1));
        }
      }
      public static double newton(double x0, double eps, int n) {
        int k = 1;
        while (Math.abs(x(k) - x(k - 1)) > eps) {
          k++;      if (k > n) {
            return 0;
          }
        }    return x(k);
      }把你的x和newton改成这样,输入1,1e-6,60。然后f和fDerivative的参数改成double x问题的关键你是拿了k去算f(x(k)),应该拿x(k)去算f(x(k))之前没看仔细,抱歉
      

  7.   


    这里有完整的实验文档,麻烦给看下!!非常感谢你能帮我答疑!!!
    http://pan.baidu.com/disk/home#dir/path=%2F%E6%88%91%E7%9A%84%E6%96%87%E6%A1%A3
    看文档,我把概念搞错了?想法哪里有偏差!!
      

  8.   


    这里有完整的实验文档,麻烦给看下!!非常感谢你能帮我答疑!!!
    http://pan.baidu.com/disk/home#dir/path=%2F%E6%88%91%E7%9A%84%E6%96%87%E6%A1%A3
    看文档,我把概念搞错了?想法哪里有偏差!!
    已经答了
      

  9.   


    代码之前有改进,和你改的差不多!但是没用!永远是算法失败!
    package 实验一;public class Test3 { static double x0; // 二分次数 public static double f(int x) {
    return x * x * x + x * x - 3 * x - 3;
    } public static double fDerivative(int x) { // 导数表达式
    return 3 * x * x + 2 * x - 3;
    } public static double x(int n) { // 递归求Xn
    if (n == 0) {
    return x0;
    } else {
    return x(n - 1) - f(n - 1) / fDerivative(n - 1);
    }
    } public static double newton(double x0, double eps, int n) { int k = 1;
    while (Math.abs(x(k) - x(k - 1)) > eps) {
    if (k > n) {
    return 0;
    }
    k++;
    } return x(k); } public static void main(String[] args) { System.out.print("请输入初始值X0:");
    x0 = KB.scanDouble();
    System.out.print("\n请输入根的容许误差限EPS的值:");
    double EPS = KB.scanDouble();
    System.out.print("\n请输入迭代次数N:");
    int n = (int) KB.scanInt();
    newton(x0, EPS, n);
    if (newton(x0, EPS, n) != 0) {
    System.out.println(newton(x0, EPS, n));
    } else {
    System.out.println("算法失败!");
    } }}
    结果永远是算法失败!难道牛顿迭代法逻辑有错?
      

  10.   

    我的可以输出结果请输入初始值X0:1请输入根的容许误差限EPS的值:1e-6请输入迭代次数N:60
    1.7320508075688774
    关键的这句你没改:
    return x(n - 1) - f(n - 1) / fDerivative(n - 1);
    仔细看我改的