【问题标题】：Java recursive Fibonacci sequenceJava递归斐波那契数列
【发布时间】：2012-02-16 09:52:18
【问题描述】：

请解释一下这个简单的代码：

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

我对最后一行感到困惑，特别是因为如果例如 n = 5，那么 fibonacci(4) + fibonacci(3) 将被调用，依此类推，但我不明白这个算法如何计算 index 处的值5 用这种方法。请详细解释！

【问题讨论】：

请注意，这是递归的并且在指数时间内运行。对于较大的 N 值，它的效率很低。使用迭代方法，我能够计算序列中的前 10,000 个数字。他们可以在这里找到 - goo.gl/hnbF5
@AdamFisher：您能分享一下您用于按顺序计算 10,000 个数字的代码吗？我其实很想知道它。
@AdamFisher 您提到的链接已失效。
本视频10分钟了解递归函数youtube.com/watch?v=t4MSwiqfLaY
还有一种迭代方法对您来说可能不太困难。关于递归和迭代的精彩文章，代码在这里 - codeflex.co/java-get-fibonacci-number-by-index

标签： java recursion fibonacci

【解决方案1】：

在斐波那契数列中，每一项都是前两项之和。所以，你写了一个递归算法。

所以，

fibonacci(5) = fibonacci(4) + fibonacci(3)

fibonacci(3) = fibonacci(2) + fibonacci(1)

fibonacci(4) = fibonacci(3) + fibonacci(2)

fibonacci(2) = fibonacci(1) + fibonacci(0)

现在您已经知道fibonacci(1)==1 and fibonacci(0) == 0。因此，您可以随后计算其他值。

现在，

fibonacci(2) = 1+0 = 1
fibonacci(3) = 1+1 = 2
fibonacci(4) = 2+1 = 3
fibonacci(5) = 3+2 = 5

从斐波那契数列0,1,1,2,3,5,8,13,21....我们可以看到，对于5th element，斐波那契数列返回5。

查看这里Recursion Tutorial。

【讨论】：

它会工作但不会优化，除非它被优化。请看看我的回答。如果有建议/cmets，请告诉我

【解决方案2】：

您的代码有 2 个问题：

结果存储在 int 中，它只能处理前 48 个斐波那契数，之后整数填充减去位，结果是错误的。
但您永远无法运行 fibonacci(50)。
代码
fibonacci(n - 1) + fibonacci(n - 2)
大错特错。
问题是它调用斐波那契的次数不是 50 次，而是更多。
起初它调用斐波那契（49）+斐波那契（48），
下一个斐波那契(48)+斐波那契(47)和斐波那契(47)+斐波那契(46)
每次它变得更糟糕的是斐波那契（n），所以复杂性是指数级的。

非递归代码的处理方法：

 double fibbonaci(int n){
    double prev=0d, next=1d, result=0d;
    for (int i = 0; i < n; i++) {
        result=prev+next;
        prev=next;
        next=result;
    }
    return result;
}

【讨论】：

虽然其他一些答案更清楚地解释了递归，但这可能是更深层次上最相关的答案。
“整数填充减去位”是什么意思？
@richard ，它是关于如何存储整数的。在 int 达到 2^31-1 之后，下一位是关于符号的，所以数字变为负数。
比递归快得多。唯一的保留是它不适用于 n=1。需要附加条件
“每次它变得更糟 2^n” 实际上总函数调用的数量是2*fibonacci(n+1)-1，所以它的增长与斐波那契数本身一样复杂，这是 1.618^n 而不是 2^n

【解决方案3】：

在伪代码中，n = 5，发生以下情况：

斐波那契(4) + 斐波那契(3)

这分解为：

(斐波那契(3) + 斐波那契(2)) + (斐波那契(2) + 斐波那契(1))

这分解为：

((((斐波那契(2)+斐波那契(1))+((斐波那契(1)+斐波那契(0)))+(((斐波那契(1)+斐波那契(0))+1))

这分解为：

(((((斐波那契(1) + 斐波那契(0)) + 1) + ((1 + 0)) + ((1 + 0) + 1))

这分解为：

((((1 + 0) + 1) + ((1 + 0)) + ((1 + 0) + 1))

这会导致：5

鉴于斐波那契数列是 1 1 2 3 5 8 ...，第 5 个元素是 5。您可以使用相同的方法来计算其他迭代。

【讨论】：

我认为这个答案最好地解释了这些问题。真的很简单
这很整洁。解释第 n 项的值及其后面的序列。

【解决方案4】：

你也可以简化你的函数，如下：

public int fibonacci(int n)  {
    if (n < 2) return n;

    return fibonacci(n - 1) + fibonacci(n - 2);
}

【讨论】：

这与this 或this 或this 答案有何不同？
它只是更短更容易阅读，哪些算法应该永远是=）
@OtavioFerreira 唯一能解决我问题的答案，干得好

【解决方案5】：

递归有时很难掌握。只需在一张纸上评估一小部分：

fib(4)
-> fib(3) + fib(2)
-> fib(2) + fib(1) + fib(1) + fib(0)
-> fib(1) + fib(0) + fib(1) + fib(1) + fib(0)
-> 1 + 0 + 1 + 1 + 0
-> 3

我不确定 Java 是如何实际评估这个的，但结果是一样的。

【讨论】：

第二行最后的1和0是哪里来的？
@pocockn fib(2) = fib(1) + fib(0)
所以你有 fib (4) 所以 n-1 和 n-2 将是 fib(3) + fib(2) 然后你再次执行 n-1 和 n-2 你得到 -> fib(2) + fib(1)，你从哪里得到 + fib(1) + fib(0)？添加到末尾
@pocockn fib(2) + fib(1) 来自 fib(3)，fib(1) + fib(0) 来自 fib(2)

【解决方案6】：

                                F(n)
                                /    \
                            F(n-1)   F(n-2)
                            /   \     /      \
                        F(n-2) F(n-3) F(n-3)  F(n-4)
                       /    \
                     F(n-3) F(n-4)

需要注意的重要一点是该算法是指数型的，因为它不存储先前计算的数字的结果。例如，F(n-3) 被调用了 3 次。

更多细节参考dasgupta第0.2章的算法

【讨论】：

有一种编程方法可以避免使用动态编程一次又一次地计算相同 n 的 F(n)

【解决方案7】：

大多数答案都很好，并解释了斐波那契递归是如何工作的。

以下是对包括递归在内的三种技术的分析：

For 循环
递归
记忆

这是我测试所有三个的代码：

public class Fibonnaci {
    // Output = 0 1 1 2 3 5 8 13

    static int fibMemo[];

    public static void main(String args[]) {
        int num = 20;

        System.out.println("By For Loop");
        Long startTimeForLoop = System.nanoTime();
        // returns the fib series
        int fibSeries[] = fib(num);
        for (int i = 0; i < fibSeries.length; i++) {
            System.out.print(" " + fibSeries[i] + " ");
        }
        Long stopTimeForLoop = System.nanoTime();
        System.out.println("");
        System.out.println("For Loop Time:" + (stopTimeForLoop - startTimeForLoop));


        System.out.println("By Using Recursion");
        Long startTimeRecursion = System.nanoTime();
        // uses recursion
        int fibSeriesRec[] = fibByRec(num);

        for (int i = 0; i < fibSeriesRec.length; i++) {
            System.out.print(" " + fibSeriesRec[i] + " ");
        }
        Long stopTimeRecursion = System.nanoTime();
        System.out.println("");
        System.out.println("Recursion Time:" + (stopTimeRecursion -startTimeRecursion));



        System.out.println("By Using Memoization Technique");
        Long startTimeMemo = System.nanoTime();
        // uses memoization
        fibMemo = new int[num];
        fibByRecMemo(num-1);
        for (int i = 0; i < fibMemo.length; i++) {
            System.out.print(" " + fibMemo[i] + " ");
        }
        Long stopTimeMemo = System.nanoTime();
        System.out.println("");
        System.out.println("Memoization Time:" + (stopTimeMemo - startTimeMemo));

    }


    //fib by memoization

    public static int fibByRecMemo(int num){

        if(num == 0){
            fibMemo[0] = 0;
            return 0;
        }

        if(num ==1 || num ==2){
          fibMemo[num] = 1;
          return 1; 
        }

        if(fibMemo[num] == 0){
            fibMemo[num] = fibByRecMemo(num-1) + fibByRecMemo(num -2);
            return fibMemo[num];
        }else{
            return fibMemo[num];
        }

    }


    public static int[] fibByRec(int num) {
        int fib[] = new int[num];

        for (int i = 0; i < num; i++) {
            fib[i] = fibRec(i);
        }

        return fib;
    }

    public static int fibRec(int num) {
        if (num == 0) {
            return 0;
        } else if (num == 1 || num == 2) {
            return 1;
        } else {
            return fibRec(num - 1) + fibRec(num - 2);
        }
    }

    public static int[] fib(int num) {
        int fibSum[] = new int[num];
        for (int i = 0; i < num; i++) {
            if (i == 0) {
                fibSum[i] = i;
                continue;
            }

            if (i == 1 || i == 2) {
                fibSum[i] = 1;
                continue;
            }

            fibSum[i] = fibSum[i - 1] + fibSum[i - 2];

        }
        return fibSum;
    }

}

结果如下：

By For Loop
 0  1  1  2  3  5  8  13  21  34  55  89  144  233  377  610  987  1597  2584  4181 
For Loop Time:347688
By Using Recursion
 0  1  1  2  3  5  8  13  21  34  55  89  144  233  377  610  987  1597  2584  4181 
Recursion Time:767004
By Using Memoization Technique
 0  1  1  2  3  5  8  13  21  34  55  89  144  233  377  610  987  1597  2584  4181 
Memoization Time:327031

因此我们可以看到记忆化是最好的时间明智并且for循环匹配紧密。

但是递归花费的时间最长，可能你应该在现实生活中避免。此外，如果您使用递归，请确保优化解决方案。

【讨论】：

"这里我们可以看到 for 循环是最好的时机"; “对于循环时间：347688”； “记忆时间：327031”； 347688 > 327031.
@CodeConfident 是的，我今天刚看到这个错误，正要纠正它。无论如何谢谢:)。

【解决方案8】：

这是我发现的最好的视频，它充分解释了 Java 中的递归和斐波那契数列。

http://www.youtube.com/watch?v=dsmBRUCzS7k

这是他的序列代码，他的解释比我试图打出来的要好。

public static void main(String[] args)
{
    int index = 0;
    while (true)
    {
        System.out.println(fibonacci(index));
        index++;
    }
}
    public static long fibonacci (int i)
    {
        if (i == 0) return 0;
        if (i<= 2) return 1;

        long fibTerm = fibonacci(i - 1) + fibonacci(i - 2);
        return fibTerm;
    }

【讨论】：

【解决方案9】：

对于斐波那契递归解决方案，重要的是保存较小斐波那契数的输出，同时检索较大数的值。这称为“记忆”。

这是一个代码，它使用记忆较小的斐波那契值，同时检索较大的斐波那契数。这段代码效率很高，不会对同一个函数进行多次请求。

import java.util.HashMap;

public class Fibonacci {
  private HashMap<Integer, Integer> map;
  public Fibonacci() {
    map = new HashMap<>();
  }
  public int findFibonacciValue(int number) {
    if (number == 0 || number == 1) {
      return number;
    }
    else if (map.containsKey(number)) {
      return map.get(number);
    }
    else {
      int fibonacciValue = findFibonacciValue(number - 2) + findFibonacciValue(number - 1);
      map.put(number, fibonacciValue);
      return fibonacciValue;
    }
  }
}

【讨论】：

【解决方案10】：

在fibonacci序列中，前两项是0和1，彼此是前两项之和。即：
0 1 1 2 3 5 8...

所以第 5 项是第 4 项和第 3 项之和。

【讨论】：

【解决方案11】：

Michael Goodrich 等人在 Java 中的数据结构和算法中提供了一个非常聪明的算法，通过返回 [fib(n), fib(n-1)] 数组在线性时间内递归求解斐波那契。

public static long[] fibGood(int n) {
    if (n < = 1) {
        long[] answer = {n,0};
        return answer;
    } else {
        long[] tmp = fibGood(n-1);
        long[] answer = {tmp[0] + tmp[1], tmp[0]};
        return answer;
    }
}

这产生 fib(n) = fibGood(n)[0]。

【讨论】：

【解决方案12】：

这是 O(1) 的解决方案：

 private static long fibonacci(int n) {
    double pha = pow(1 + sqrt(5), n);
    double phb = pow(1 - sqrt(5), n);
    double div = pow(2, n) * sqrt(5);

    return (long) ((pha - phb) / div);
}

Binet's Fibonacci number formula 用于上述实现。对于较大的输入，long 可以替换为 BigDecimal。

【讨论】：

【解决方案13】：

斐波那契数列是将一个数字的结果与以 1 开头的前一个结果相加的结果相加。

      so.. 1 + 1 = 2
           2 + 3 = 5
           3 + 5 = 8
           5 + 8 = 13
           8 + 13 = 21

一旦我们了解斐波那契是什么，我们就可以开始分解代码了。

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

第一个 if 语句检查基本情况，循环可能会中断。下面的 else if 语句也是这样做的，但它可以像这样重写......

    public int fibonacci(int n)  {
        if(n < 2)
             return n;

        return fibonacci(n - 1) + fibonacci(n - 2);
    }

既然已经建立了基本情况，我们必须了解调用堆栈。您对“斐波那契”的第一次调用将是最后一个在堆栈（调用序列）上解析的调用，因为它们以相反的顺序解析叫。最后一个调用的方法首先解析，然后是在该方法之前调用的最后一个，依此类推...

因此，在使用这些结果“计算”任何内容之前，首先会进行所有调用。输入为 8，我们预计输出为 21（见上表）。

fibonacci(n - 1) 一直被调用，直到达到基本情况，然后 fibonacci(n - 2) 被调用，直到达到基本情况。当堆栈开始以相反的顺序对结果求和时，结果将是这样的......

1 + 1 = 1        ---- last call of the stack (hits a base case).
2 + 1 = 3        ---- Next level of the stack (resolving backwards).
2 + 3 = 5        ---- Next level of the stack (continuing to resolve).

他们不断冒泡（向后解析）直到正确的和返回到堆栈中的第一个调用，这就是你得到答案的方式。

话虽如此，该算法的效率非常低，因为它为代码分成的每个分支计算相同的结果。一种更好的方法是“自下而上”，不需要记忆（缓存）或递归（深度调用堆栈）。

就这样……

        static int BottomUpFib(int current)
        {
            if (current < 2) return current;

            int fib = 1;
            int last = 1;

            for (int i = 2; i < current; i++)
            {
                int temp = fib;
                fib += last;
                last = temp;
            }

            return fib;
        }

【讨论】：

【解决方案14】：

这里提供的大多数解决方案都以 O(2^n) 复杂度运行。在递归树中重新计算相同的节点效率低下并且浪费 CPU 周期。

我们可以使用 memoization 让斐波那契函数在 O(n) 时间内运行

public static int fibonacci(int n) {
    return fibonacci(n, new int[n + 1]);
}

public static int fibonacci(int i, int[] memo) {

    if (i == 0 || i == 1) {
        return i;
    }

    if (memo[i] == 0) {
        memo[i] = fibonacci(i - 1, memo) + fibonacci(i - 2, memo);
    }
    return memo[i];
}

如果我们遵循自下而上的动态规划路线，下面的代码很简单，可以计算斐波那契：

public static int fibonacci1(int n) {
    if (n == 0) {
        return n;
    } else if (n == 1) {
        return n;
    }
    final int[] memo = new int[n];

    memo[0] = 0;
    memo[1] = 1;

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

【讨论】：

【解决方案15】：

为什么这个答案不同

其他答案：

打印而不是退货
每次迭代进行 2 次递归调用
使用循环忽略问题

（除此之外：这些都不是真正有效的；使用Binet's formula 直接计算第n^th 项）

尾递归Fib

这是一种递归方法，它通过传递前一个答案和之前的答案来避免双重递归调用。

private static final int FIB_0 = 0;
private static final int FIB_1 = 1;

private int calcFibonacci(final int target) {
    if (target == 0) { return FIB_0; }
    if (target == 1) { return FIB_1; }

    return calcFibonacci(target, 1, FIB_1, FIB_0);
}

private int calcFibonacci(final int target, final int previous, final int fibPrevious, final int fibPreviousMinusOne) {
    final int current = previous + 1;
    final int fibCurrent = fibPrevious + fibPreviousMinusOne;
    // If you want, print here / memoize for future calls

    if (target == current) { return fibCurrent; }

    return calcFibonacci(target, current, fibCurrent, fibPrevious);
}

【讨论】：

【解决方案16】：

这是显示或获取输出的基本序列 1 1 2 3 5 8 它是一个序列，下一个显示当前数字的前一个数字的总和。

尝试观看Java递归斐波那契数列教程下方的链接

public static long getFibonacci(int number){
if(number<=1) return number;
else return getFibonacci(number-1) + getFibonacci(number-2);
}

点击这里Watch Java Recursive Fibonacci sequence Tutorial用勺子喂

【讨论】：

他需要了解的是代码是如何工作的，以及为什么要以这种方式编写代码。
我想我在第一句话中提到了它是如何工作的？我编写代码以使其更简单。顺便说一句，对不起。
您的代码没有问题。只有那个人想了解该代码是如何工作的。检查 RanRag 的答案。那种东西:)
啊，好吧，对不起，我是 stackoverflow 的初学者。只是想帮忙^_^

【解决方案17】：

我认为这是一个简单的方法：

public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int number = input.nextInt();
        long a = 0;
        long b = 1;
        for(int i = 1; i<number;i++){
            long c = a +b;
            a=b;
            b=c;
            System.out.println(c);
        }
    }
}

【讨论】：

【解决方案18】：

RanRag(accepted) 答案可以正常工作，但这不是优化的解决方案，除非按照 Anil 答案中的说明记住它。

对于递归考虑以下方法，TestFibonacci 的方法调用最少

public class TestFibonacci {

    public static void main(String[] args) {

        int n = 10;

        if (n == 1) {
            System.out.println(1);

        } else if (n == 2) {
            System.out.println(1);
            System.out.println(1);
        } else {
            System.out.println(1);
            System.out.println(1);
            int currentNo = 3;
            calFibRec(n, 1, 1, currentNo);
        }

    }

    public static void calFibRec(int n, int secondLast, int last,
            int currentNo) {
        if (currentNo <= n) {

            int sum = secondLast + last;
            System.out.println(sum);
            calFibRec(n, last, sum, ++currentNo);
        }
    }

}

【讨论】：

【解决方案19】：

public class febo 
{
 public static void main(String...a)
 {
  int x[]=new int[15];  
   x[0]=0;
   x[1]=1;
   for(int i=2;i<x.length;i++)
   {
      x[i]=x[i-1]+x[i-2];
   }
   for(int i=0;i<x.length;i++)
   {
      System.out.println(x[i]);
   }
 }
}

【讨论】：

【解决方案20】：

通过使用理论上可能允许的内部 ConcurrentHashMap 这种递归实现可以在多线程中正确运行环境中，我实现了一个使用 BigInteger 的 fib 函数和递归。计算前 100 个 fib 数字大约需要 53 毫秒。

private final Map<BigInteger,BigInteger> cacheBig  
    = new ConcurrentHashMap<>();
public BigInteger fibRecursiveBigCache(BigInteger n) {
    BigInteger a = cacheBig.computeIfAbsent(n, this::fibBigCache);
    return a;
}
public BigInteger fibBigCache(BigInteger n) {
    if ( n.compareTo(BigInteger.ONE ) <= 0 ){
        return n;
    } else if (cacheBig.containsKey(n)){
        return cacheBig.get(n);
    } else {
        return      
            fibBigCache(n.subtract(BigInteger.ONE))
            .add(fibBigCache(n.subtract(TWO)));
    }
}

测试代码为：

@Test
public void testFibRecursiveBigIntegerCache() {
    long start = System.currentTimeMillis();
    FibonacciSeries fib = new FibonacciSeries();
    IntStream.rangeClosed(0,100).forEach(p -&R {
        BigInteger n = BigInteger.valueOf(p);
        n = fib.fibRecursiveBigCache(n);
        System.out.println(String.format("fib of %d is %d", p,n));
    });
    long end = System.currentTimeMillis();
    System.out.println("elapsed:" + 
    (end - start) + "," + 
    ((end - start)/1000));
}

测试的输出是： . . . . . 93的fib是12200160415121876738 94的fib是19740274219868223167 95的fib是31940434634990099905 96 的 fib 是 51680708854858323072 97的fib是83621143489848422977 98的fib是135301852344706746049 99的fib是218922995834555169026 fib 100 是 354224848179261915075 经过：58,0

【讨论】：

【解决方案21】：

这是一个单行 febonacci 递归：

public long fib( long n ) {
        return n <= 0 ? 0 : n == 1 ? 1 : fib( n - 1 ) + fib( n - 2 );
}

【讨论】：

【解决方案22】：

作为补充，如果你想计算更大的数，你应该使用 BigInteger。

一个迭代的例子。

import java.math.BigInteger;
class Fibonacci{
    public static void main(String args[]){
        int n=10000;
        BigInteger[] vec = new BigInteger[n];
        vec[0]=BigInteger.ZERO;
        vec[1]=BigInteger.ONE;
        // calculating
        for(int i = 2 ; i<n ; i++){
            vec[i]=vec[i-1].add(vec[i-2]);
        }
        // printing
        for(int i = vec.length-1 ; i>=0 ; i--){
            System.out.println(vec[i]);
            System.out.println("");
        }
    }
}

【讨论】：

【解决方案23】：

http://en.wikipedia.org/wiki/Fibonacci_number 更多详情

public class Fibonacci {

    public static long fib(int n) {
        if (n <= 1) return n;
        else return fib(n-1) + fib(n-2);
    }

    public static void main(String[] args) {
        int N = Integer.parseInt(args[0]);
        for (int i = 1; i <= N; i++)
            System.out.println(i + ": " + fib(i));
    }

}

让它尽可能简单，无需使用while循环和其他循环

【讨论】：

【解决方案24】：

public class FibonacciSeries {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int N = scanner.nextInt();
        for (int i = 0; i <= N; i++) {
            int result = fibonacciSeries(i);
            System.out.println(result);
        }
        scanner.close();
    }

    private static int fibonacciSeries(int n) {
        if (n < 0) {
            return 1;
        } else if (n > 0) {
            return fibonacciSeries(n - 1) + fibonacciSeries(n - 2);
        }
        return 0;
    }
}

【讨论】：

【解决方案25】：

使用while:

public int fib(int index) {
    int tmp = 0, step1 = 0, step2 = 1, fibNumber = 0;
    while (tmp < index - 1) {
        fibNumber = step1 + step2;
        step1 = step2;
        step2 = fibNumber;
        tmp += 1;
    };
    return fibNumber;
}

这种方案的优点是代码易于阅读和理解，希望能有所帮助

【讨论】：

【解决方案26】：

斐波那契数列是对一个数的结果求和的数列然后我们添加到之前的结果，我们应该从 1 开始。我试图找到一个基于算法的解决方案，所以我构建了递归代码，注意到我保留了以前的数字并且我改变了位置。我正在搜索从 1 到 15 的斐波那契数列。

public static void main(String args[]) {

    numbers(1,1,15);
}


public static int numbers(int a, int temp, int target)
{
    if(target <= a)
    {
        return a;
    }

    System.out.print(a + " ");

    a = temp + a;

    return numbers(temp,a,target);
}

【讨论】：

【解决方案27】：

试试这个

private static int fibonacci(int n){
    if(n <= 1)
        return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

【讨论】：

【解决方案28】：

我找不到带有三元运算符的简单单行。所以这里有一个：

public int fibonacci(int n) {
    return (n < 2) ? n : fibonacci(n - 2) + fibonacci(n - 1);
}

【讨论】：

【解决方案29】：

 public static long fib(int n) {
    long population = 0;

    if ((n == 0) || (n == 1)) // base cases
    {
        return n;
    } else // recursion step
    {

        population+=fib(n - 1) + fib(n - 2);
    }

    return population;
}

【讨论】：

【解决方案30】：

简单的斐波那契

public static void main(String[]args){

    int i = 0;
    int u = 1;

    while(i<100){
        System.out.println(i);
        i = u+i;
        System.out.println(u);
        u = u+i;
    }
  }
}

【讨论】：

欢迎来到 SO。虽然您的答案确实计算了斐波那契数列。您的回答没有回答询问递归函数的 OP。