Java 将for循环转换为递归函数

这是一个家庭作业问题。我无法将以下内容转换为递归函数：

public class Integrate {
    public static double integrate(int  a, int b, int steps)
    {
        double sum=0;
        double delta = 1.0 * (b - a)/steps;
        double x = a;
        double f = 0.5*x*x + 3*x + 5;

        for (int i = 0; i< steps; i++)
        {
            x = x + delta;
            double fr = 0.5*x*x + 3*x + 5;
            double area = f * delta + 0.5*(fr - f)*delta;
            sum += area;
            f = fr;
        }
        return sum;
    }
    public static void main(String [] args)
    {
        int a, b, step;
        a = Integer.parseInt(args[0]);
        b = Integer.parseInt(args[1]);
        step = Integer.parseInt(args[2]);
        System.out.format("Integral is %f\n", integrate(a,b,step));
    }
}

公共类集成{
公共静态双积分（整数a、整数b、整数步）
{
双和=0；
双增量=1.0*（b-a）/步数；
双x=a；
双f=0.5*x*x+3*x+5；
对于（int i=0；i

这是我到目前为止所拥有的，但是输出与原始代码不同。我想不出是怎么回事

public class Integrate {

    public static double integrate(int a, int b, int steps) {
        double sum=0;
        int i=0;
        sum = rintegrate(a, b, steps, i, sum);
        return sum;
    }

    public static double rintegrate(int a, int b, int steps, 
            int i, double sum) {
        double delta = 1.0 * (b - a)/steps;
        double x = a;
        double f = 0.5*x*x + 3*x + 5;
        if (i<steps) {
            x = x + delta;
            double fr = 0.5*x*x + 3*x + 5;
            double area = f * delta + 0.5*(fr - f)*delta;
            sum += area;
            f = fr;
            i++;
            rintegrate(a, b, steps, i, sum);
        }
        return sum;
    }

    public static void main(String[] args) {
        int a, b, step;
        a = Integer.parseInt(args[0]);
        b = Integer.parseInt(args[1]);
        step = Integer.parseInt(args[2]);
        System.out.format("Integral is %f\n", integrate(a,b,step));
    }

}

公共类集成{
公共静态双积分（整数a、整数b、整数步）{
双和=0；
int i=0；
总和=R综合（a，b，步骤，i，总和）；
回报金额；
}
公共静态双打印集成（int a、int b、int steps、，
整数i（双倍和）{
双增量=1.0*（b-a）/步数；
双x=a；
双f=0.5*x*x+3*x+5；
如果（i我不打算完全分析这个问题，但这里有一些观察结果

    if (i<steps) {
        x = x + delta;
        double fr = 0.5*x*x + 3*x + 5;
        double area = f * delta + 0.5*(fr - f)*delta;
        sum += area;
        f = fr;
        i++;
        rintegrate(a, b, steps, i, sum);
    }
    return sum;

工作版本

只需复制粘贴，您将获得与原始方法相同的输出

   public static void main(String[] args) {
        int a = 1, b = 10, step = 1000;
            double delta = 1.0 * (b - a) / step;
        double sum = integrate(a, b, step, 0, 0, 0, delta);
        double test = working(a, b, step);
        System.out.println("Integral is " + sum);
        System.out.println("Integral is " + test);
    }

工作递归版本：

    public static double integrate(double x, int b, int steps, int i,
            double sum, double f, double delta) { 
        f = 0.5 * x * x + 3 * x + 5;
        if (i < steps) {
            x = x + delta;
            double fr = 0.5 * x * x + 3 * x + 5;
            double area = f * delta + 0.5 * (fr - f) * delta;
            return integrate(x, b, steps, i + 1, sum + area, fr, delta);
        }
        return sum;
    }

公共静态双积分（双x、整数b、整数步数、整数i、，
双和，双f，双delta）{
f=0.5*x*x+3*x+5；
如果（i<步骤）{
x=x+delta；
双fr=0.5*x*x+3*x+5；
双面积=f*三角洲+0.5*（fr-f）*三角洲；
返回积分（x，b，步长，i+1，和+面积，fr，增量）；
}
回报金额；
}

您最初的迭代方法；

public static double working(int a, int b, int steps) {
    double sum = 0;
    double delta = 1.0 * (b - a) / steps;
    double x = a;
    double f = 0.5 * x * x + 3 * x + 5;

    for (int i = 0; i < steps; i++) {
        x = x + delta;
        double fr = 0.5 * x * x + 3 * x + 5;
        double area = f * delta + 0.5 * (fr - f) * delta;
        sum += area;
        f = fr;
    }
    return sum;
}

公共静态双重工作（int a、int b、int步骤）{
双和=0；
双增量=1.0*（b-a）/步数；
双x=a；
双f=0.5*x*x+3*x+5；
对于（int i=0；i
这就是你想要的；）

公共类集成{
/**
*@param args
*/
公共静态void main（字符串[]args）{
int a，b，步骤；
a=Integer.parseInt（args[0]）；
b=整数.parseInt（args[1]）；
step=Integer.parseInt（args[2]）；
System.out.format（“整数为%f\n”，
自适应采样（a，b，step））；
}
专用静态双f（双i）{
回报率（0.5*i*i+3*i+5）；
}
静态双自适应采样（双a，双b，//间隔[a，b]
int maxRecursionDepth）{//递归上限
双c=（a+b）/2，h=b-a；
双fa=f（a），fb=f（b），fc=f（c）；
双S=（h/6）*（fa+4*fc+fb）；
返回自适应IMPSONSAUX（a、b、S、fa、fb、fc、maxRecursionDepth）；
}
专用静态双自适应IMPSONSAUX（双a、双b、双S、双fa、，
双fb、双fc、int（底部）{
双c=（a+b）/2，h=b-a；
双d=（a+c）/2，e=（c+b）/2；
双fd=f（d），fe=f（e）；
双Sleft=（h/12）*（fa+4*fd+fc）；
双Sright=（h/12）*（fc+4*fe+fb）；
双S2=长距离+短距离；
如果（底部原始代码的输出是什么？新代码的输出是什么？看起来您没有递归地使用
rintegrate
的返回值…a=1，b=10，step=1000……。原始结果为360.000061，我的输出为0.076662 Luiggi Mendoza，我不明白。我如何使用返回值re草率地？我想他的意思是你不是在rintegrate（）内部使用它.这可能就是你的问题所在。嗨，谢谢你的帮助。你的代码也没有给出正确的输出。硬件问题说是从integrate调用rintegrate，这就是为什么我首先使用rintegrate方法的原因。我明白了。你的方法现在可以工作了。这不是我想要的，但看看我的方法有什么问题是很有帮助的。我不知道在您的版本中，从何处计算增量？谢谢，我现在有了一个有效的解决方案，在递归方法之外声明了增量和x。但是，如果与它们相关联的变量都没有改变，为什么它们在调用之间会有所不同？在您的示例中，是从步骤开始计算，然后再向下计算吗？有没有一种方法可以从0开始？@user2378481您仍在反复思考问题。请尝试递归思考问题。您的函数需要将一个段添加到其余段的总和中，然后返回该值。这仍然有点难以理解。这是否像是将上一步的所有内容都继承了下来？抱歉，递归看起来就像一个循环对我来说。@user2378481这样想。假设我从示例中调用了迭代的
integrate
函数，而不是调用递归的
reintegrate
函数。这样的示例有意义吗？不，没有。递归有什么原因吗？它看起来更复杂，输出也不太明显n您可以递归地重写这个问题。不，您尝试递归地进行的集成可以使用辛普森算法递归地完成，因此这些方法的名称就是这样命名的。您看过代码了吗？它递归地将函数0.5x^2+3x+5集成到给定的步骤数，如前所述
public static double working(int a, int b, int steps) {
    double sum = 0;
    double delta = 1.0 * (b - a) / steps;
    double x = a;
    double f = 0.5 * x * x + 3 * x + 5;

    for (int i = 0; i < steps; i++) {
        x = x + delta;
        double fr = 0.5 * x * x + 3 * x + 5;
        double area = f * delta + 0.5 * (fr - f) * delta;
        sum += area;
        f = fr;
    }
    return sum;
}

public class Integrate{

    /**
     * @param args
     */
    public static void main(String[] args) {
        int a, b, step;
        a = Integer.parseInt(args[0]);
        b = Integer.parseInt(args[1]);
        step = Integer.parseInt(args[2]);
        System.out.format("Integral is %f\n",
                adaptiveSimpsons(a, b, step));

    }

    private static double f(double i) {
        return (0.5 * i * i + 3 * i + 5);
    }

    static double adaptiveSimpsons(double a, double b, // interval [a,b]
            int maxRecursionDepth) { // recursion cap
        double c = (a + b) / 2, h = b - a;
        double fa = f(a), fb = f(b), fc = f(c);
        double S = (h / 6) * (fa + 4 * fc + fb);
        return adaptiveSimpsonsAux(a, b, S, fa, fb, fc, maxRecursionDepth);
    }

    private static double adaptiveSimpsonsAux(double a, double b, double S, double fa,
            double fb, double fc, int bottom) {
        double c = (a + b) / 2, h = b - a;
        double d = (a + c) / 2, e = (c + b) / 2;
        double fd = f(d), fe = f(e);
        double Sleft = (h / 12) * (fa + 4 * fd + fc);
        double Sright = (h / 12) * (fc + 4 * fe + fb);
        double S2 = Sleft + Sright;
        if (bottom <= 0)
            return S2 + (S2 - S) / 15;
        return adaptiveSimpsonsAux(a, c, Sleft, fa, fc, fd, bottom - 1)
                + adaptiveSimpsonsAux(c, b, Sright, fc, fb, fe, bottom - 1);
    }
}