将数字数组传递给递归 Java 程序

Question

我正在编写一个显示 m(i) 的程序，i = 1,2,3,4,5,107,1060。结果应该是双精度值。而级数是 m(i) = 1/2 + 2/3 +.....i/i+1

我正在尝试使用数组传递所需的数字。但是我遇到了兼容性问题。到目前为止，我有这个：

public class Recursive {
    public static void main(String[] args){
        int[] s;
        s = new int[]{1,2,3,4,5,107,1060};

        System.out.println(""   ,m(s));
    }

    public static double m(int i){
        double result;
        if(i > 1){
            result = i/(i + 1) + m(i - 1);
        } else{
            result = i/(i + 1);
        }
        return result;
    }
}

Answer 1

根据您收到的 cmets，大多数人认为您的问题是：

public class Recursive {

    public static double m(int i) {
        double result = i / (i + 1.0);

        if (i > 1) {
            result += m(i - 1);
        }

        return result;
    }

    public static void main(String[] args) {
        int[] s = {1, 2, 3, 4, 5, 107, 1060};

        for (int i : s) { 
            System.out.println("m(" + i + ") = " + m(i));
        }
    }
}

因为顺序应该是 1/2 + 2/3 + 3/4 + 4/5+ 5/6 + 107/108+ 1060/1061

这表明您确实在要求：

public class Recursive {

    public static double m(int i, int[] s) {
        double result = s[i] / (s[i] + 1.0);

        if (i > 0) {
            result += m(i - 1, s);
        }

        return result;
    }

    public static void main(String[] args) {
        int[] s = {1, 2, 3, 4, 5, 107, 1060};

        System.out.println(m(s.length - 1, s));
    }
}

除非s 是一个空数组，否则这有效——就像您问题的其他潜在答案一样。

Answer 2

首先您需要将数组作为参数传递给方法m()，
或者您可以在类级别声明数组以避免递归开销。
对于这个小数组，让我们采用第一种方法。
然后，在m() 内部，您犯了一个必须修复的逻辑错误。
您需要总结 s[i]/s[i] + 1 而不是 i / (i + 1)。
还有if语句中的条件从i > 1到i > 0，因为数组的索引是基于0的：

public static void main(String[] args){
    int[] s = new int[]{1, 2, 3, 4, 5, 107, 1060};
    System.out.println(m(s, 6));
}

public static double m(int[] s, int i){
    double result;
    if(i > 0){
        result = 1.0 * s[i]/(s[i] + 1) + m(s, i - 1);
    } else{
        result = 1.0 * s[i]/(s[i] + 1);
    }
    return result;
}

需要乘以1.0的因子以避免整数除法：

s[i]/(s[i] + 1) 

这总是会导致0

Answer 3

m() 方法需要一个 int 参数，但您传递的是整个数组。保留一个 for 循环并为每个元素传递 m() 或处理 m() 中的逻辑