将迭代方法转换为递归方法（Java）

对于我在uni的离散结构类，我需要编写一个方法来解决以下公式：

s[0]=1

s[n-1]=s[n-2]+n表示所有n>=2

不幸的是，我以前没有实现过很多递归方法，所以我真的不知道我在做什么。事情对我来说并不像平常那样“咔哒”一声

我非常感谢任何可能的帮助，但我更愿意完全理解这一点，而不仅仅是复制粘贴别人的作品

如果n=8，该方法应实现的基本示例

1+2=3

3+3=6

6+4=10

10+5=15

15+6=21

21+7=28

28+8=36，我们的答案。

我已经写了一个非递归（如下所示）解决这个问题的方法，所以我理解它背后的数学原理

public static int sequenceNonRecursive(int n){
    int[] s = new int[n];
    s[0] = 1;

    if(n >= 2){
        for(int i = 1; i < n; i++){
            s[i] = s[i-1] + i + 1;
        }
    }
    return s[n-1];
}

公共静态int序列非递归（int n）{
int[]s=新的int[n]；
s[0]=1；
如果（n>=2）{
对于（int i=1；i

---

编辑：我解决了它。谢谢大家的帮助！请看下面我的答案。

将您的代码按如下方式构造（只是给出提示，让您找出问题的其余部分）：

---

递归就像将原始问题分解成子问题并试图解决它们。首先，您需要找出基本情况（在您的情况下是

n=0

）。现在，您可以继续前进，看看如何通过将

n>0

分解为基本情况来处理这些情况。为

n

然后

n-1

然后

n-2

等等创建序列，直到达到基本情况为止，这是递归解决此问题的关键。

让我们首先在第二个等式中的所有

n

中添加1：（如果我们增加它们，我们需要减小范围，因为它是正确的，应该是微不足道的）

我们为什么要这样做？
简而言之，函数定义是

sequence（intn）

，而不是

sequence（intn-1）

这里的

s[i]

只对应于使用输入参数

i

调用函数

代码的基本思想是：

public static int sequence(int n){
    if (/* base case */)
        // return value for base case
    else
        // return other case, includes calling sequence(x) for some x
}

---

希望这能给你足够的时间来工作。

实际上更容易。假设您的方法适用于所有n，除非n为零（基本情况）

获取上一个数字的值并期望它正常工作。（而且会）

---

在引擎盖下，它将递归到基本情况，并在调用返回时建立值。

递归的定义有点奇怪。我会重写它：

S0=1
Si=Si-1+i+1-∀ i>0

该例程可以简化为不使用数组：

public static int sequenceNonRecursive (int n) {
    int S_0 = 1;                      // 0th term is 1
    int S_i = S_0;                    // S_i starts at S_0
    for(int i = 1; i <= n; i++) {
        int S_i_minus_1 = S_i;        // use previous result to calculate next
        S_i = S_i_minus_1 + i + 1;    // next is previous added with index plus 1
    }
    return S_i;
}

然后，可以将此函数的主体更改为调用递归函数：

public static int someFunction (int n) {
    return someFunctionWithRecursion(n, 0, DEFAULT_RESULT);
}

请注意，局部变量的初始值是如何转换为递归例程的参数的。因此，递归例程本身可能如下所示：

public static int someFunctionWithRecursion (int n, int i, int result) {
    if (! (i < n)) {
        return result;
    }
    result = UPDATE_RESULT(i, n, result);
    return someFunctionWithRecursion(n, i+1, result);
}

带有递归的公共静态int-somefunction（int-n，int-i，int-result）{
如果（！（i

请注意，在递归调用中，

结果

已经更新，控制变量

i

已经增加，就像迭代在原始的

for（）

循环版本的代码中所做的那样

顺便说一句：您正在处理的循环实际上有一个封闭的形式：

序号=（½）（n+1）（n+2）

---

我明白了，伙计们。谢谢大家的帮助！我不敢相信这是多么愚蠢的简单。我一弄明白，就给了自己一个有力的掌心。我很确定我现在理解递归了

public static int sequenceRecursive(int n){
       if( n == 0 )
            return 0;
        else
            return n + sequenceRecursive(n-1);
}

---

你确定这是对的吗？您打算

sequenceNonRecursive（0）

返回什么？@jxh:顶部指定的OP

sequenceNonRecursive（0）==1

。如果你碰巧因为这个原因否决了这个问题，请撤销否决票。@music_coder:不是我的否决票（我不否决）<代码>序列非递归（0）将导致

返回s[-1]

，我想知道这是否是出于设计，因为它会影响递归解决方案。每个发表评论的人都帮了我的忙（谢谢大家！），但我认为你的回答是最简洁的。“我弄明白了。”德雷克德林农很高兴我能帮上忙。一定要找到最有帮助的。

public static int someFunction (int n) {
    int result = DEFAULT_RESULT;
    for (int i = 0; i < n; ++i) {
        result = UPDATE_RESULT(i, n, result);
    }
    return result;
}

public static int someFunction (int n) {
    return someFunctionWithRecursion(n, 0, DEFAULT_RESULT);
}

public static int someFunctionWithRecursion (int n, int i, int result) {
    if (! (i < n)) {
        return result;
    }
    result = UPDATE_RESULT(i, n, result);
    return someFunctionWithRecursion(n, i+1, result);
}

public static int sequenceRecursive(int n){
       if( n == 0 )
            return 0;
        else
            return n + sequenceRecursive(n-1);
}