小开

在 Fibonacci序列中，前两项是0和1，对方项是前两项的总和。即:
0112358.

所以第五项是第四项和第三项的总和。

小开

最佳答案

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

那么,

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

从 fibonacci 序列 0,1,1,2,3,5,8,13,21....我们可以看到，对于 5th element，fibonacci 序列返回 5。

看这里的递归教程。

小开

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

Fibonacci (4) + fibonnacci (3)

这可以分为:

(fibonacci (3) + fibonnacci (2)) + (fibonacci (2) + fibonnacci (1))

这可以分为:

((((fibonacci (2) + fibonnacci (1))) + ((fibonacci (1) + fibonnacci (0)))) + (((fibonacci (1) + fibonnacci (0)) + 1)))

这可以分为:

((((fibonacci (1) + fibonnacci (0)) + 1) + ((1 + 0)) + ((1 + 0) + 1))

这可以分为:

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

结果是: 5

给定 fibonnacci 序列是 112358.，第5个元素是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 实际上是如何计算的，但结果是一样的。

小开

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

小开

它是显示或获取 112358 它是一个序列，前一个数字的和当前的数字将显示下一个。

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

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

点击这里观看 Java 递归斐波那契序列教程勺喂

小开

这是我找到的最好的视频，它完全解释了 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;
}

小开

作为补充，如果希望能够计算更大的数，应该使用 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("");
}
}
}

小开

public class Fibonaci{


static void fibonacci() {
int ptr1 = 1, ptr2 = 1, ptr3 = 0;
int temp = 0;
BufferedReader Data=new BufferedReader (new InputStreamReader(System.in));
try {
System.out.println("The Number Value's fib you required ? ");
ptr3 = Integer.parseInt(Data.readLine());


System.out.print(ptr1 + " " + ptr2 + " ");
for (int i = 0; i < ptr3; i++) {
System.out.print(ptr1 + ptr2 + " ");
temp = ptr1;
ptr1 = ptr2;
ptr2 = temp + ptr2;
}
} catch(IOException err) {
System.out.println("Error!" + err);
} catch(NumberFormatException err) {
System.out.println("Invald Input!");
}
}


public static void main(String[]args)throws Exception{
Fibonaci.fibonacci();
}
}

你可以这样做。

小开

您的代码有两个问题:

结果存储在 int 中，它只能处理前48个斐波那契数字，之后整数填充减位并且结果是错误的。
但是你永远不能运行斐波那契(50)。
密码
fibonacci(n - 1) + fibonacci(n - 2)
大错特错。
问题是它调用 fibonacci 的次数不止50次，而是更多。
首先它调用 fibonacci (49) + fibonacci (48) ,
接下来是 fibonacci (48) + fibonacci (47)和 fibonacci (47) + fibonacci (46)
每次它都变得更糟糕，所以复杂度是指数级的。

非递归代码的方法:

 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;
}

小开

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 循环和其他循环

小开

斐波那契数列是一个简单的代码，显示了动态编程的力量。我们从学生时代学到的就是通过迭代或最大递归代码来运行它。递归代码可以正常工作到20左右，如果你给出的数字大于这个数字，你将看到它需要很多时间来计算。在动态编程中，你可以编写如下代码，计算答案只需几秒钟。

static double fib(int n) {
if (n < 2)
return n;
if (fib[n] != 0)
return fib[n];
fib[n] = fib(n - 1) + fib(n - 2);
return fib[n];
}

将值存储在数组中，只有在数组无法提供答案时才进行新的计算。

小开

                                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章的算法

小开

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

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);
}
}
}

小开

    import java.util.*;
/*
@ Author 12CSE54
@ Date 28.10.14
*/
public class cfibonacci
{
public void print(int p)
{
int a=0,b=1,c;
int q[]=new int[30];
q[0]=a;
q[1]=b;
for(int i=2;i<p;i++)
{
c=a+b;
q[i]=c;
a=b;
b=c;
}
System.out.println("elements are....\n");
for(int i=0;i<q.length;i++)
System.out.println(q[i]);
}
public static void main(String ar[])throws Exception
{
Scanner s=new Scanner(System.in);
int n;
System.out.println("Enter the number of elements\n");
n=sc.nextInt();
cfibonacci c=new cfibonacci();
c.printf(n);


}
}

小开

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

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]。

小开

对于斐波那契递归解，保存较小斐波那契数的输出，同时检索较大数的值是非常重要的。这就是所谓的“记忆”。

下面是一段代码，它使用的是较小的斐波那契数值(fibonacci)的记忆，同时检索较大的斐波那契数列。这段代码效率很高，不会对同一个函数发出多个请求。

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;
}
}
}

小开

@ chro 是正确的，但是他/她没有给出正确的递归方法，这是解决方案:

class Fib {
static int count;


public static void main(String[] args) {
log(fibWrong(20));  // 6765
log("Count: " + count); // 21891
count = 0;
log(fibRight(20)); // 6765
log("Count: " + count); // 19
}


static long fibRight(long n) {
return calcFib(n-2, 1, 1);
}


static long fibWrong(long n) {
count++;
if (n == 0 || n == 1) {
return n;
} else if (n < 0) {
log("Overflow!");
System.exit(1);
return n;
} else {
return fibWrong(n-1) + fibWrong(n-2);
}


}


static long calcFib(long nth, long prev, long next) {
count++;
if (nth-- == 0)
return next;
if (prev+next < 0) {
log("Overflow with " + (nth+1)
+ " combinations remaining");
System.exit(1);
}
return calcFib(nth, next, prev+next);
}


static void log(Object o) {
System.out.println(o);
}
}

小开

 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;
}

小开

你也可以简化你的职能，如下:

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


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

小开

与使用数组和做一些花哨的事情相反，仅仅两个值相加是浪费时间，我已经找到了一种显示/打印的有效方法，著名的斐波那契数列。

public static void main(String args[]){


System.out.println("This program lists the Fibonacci sequence.");


int answer = 0;
int startValue = 1;
int sum = 0;


while (answer < 10000){


System.out.println(answer);


sum = add(answer,startValue);


startValue = answer;
answer = sum;
}
}
//This method return the sum of addition
private static int add(int A,int B){
return A+B;
}

小开

RanRag (接受)答案将工作良好，但这不是优化的解决方案，直到和除非它是记住在 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);
}
}


}

小开

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

我们可以用制表法使斐波那契函数在 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];
}

小开

简单的斐波那契数

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;
}
}
}

小开

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

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

为了鲁普
递归
纪念

下面是我测试这三种方法的代码:

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

因此，我们可以看到制表是最好的 时间智慧和循环紧密匹配。

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

小开

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]);
}
}
}

小开

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;
}
}

小开

为什么这个答案不同

其他的答案都是:

指纹而不是退货
每次迭代进行2次递归调用
通过使用循环忽略该问题

(除此之外: 这些都不是有效的; 使用比奈的配方直接计算 n^这个项)

尾部递归纤维

这里有一种递归方法，它通过同时传递前一个答案和前一个答案来避免双重递归调用。

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);
}

小开

Fibbonacci 序列是将一个数字的结果加到以1开头的前一个结果后求和的序列。

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

一旦我们理解了 Fibbonacci 是什么，我们就可以开始分解代码了。

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);
}

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

因此，所有的调用都是首先进行的，然后才“计算”这些结果。输入为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).

它们不断冒泡(向后解析) ，直到将正确的和返回到堆栈中的第一个调用，这就是您得到答案的方法。

尽管如此，这个算法是非常低效的，因为它为代码分裂成的每个分支计算相同的结果。一种更好的方法是“自底向上”的方法，这种方法不需要 Memization (缓存)或递归(深度调用堆栈)。

像这样..。

        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;
}

小开

通过使用内部 ConcurrentHashMap，理论上可以允许这个递归实现可以在多线程中正确操作环境中，我已经实现了一个 fib 函数，它同时使用 BigInteger 和递归。需要大约53毫秒来计算前100个小谎数。

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));
}

and output from the test is:
.
.
.
.
.
fib of 93 is 12200160415121876738
fib of 94 is 19740274219868223167
fib of 95 is 31940434634990099905
fib of 96 is 51680708854858323072
fib of 97 is 83621143489848422977
fib of 98 is 135301852344706746049
fib of 99 is 218922995834555169026
fib of 100 is 354224848179261915075
elapsed:58,0

小开

下面是一行 febonacci 递归:

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

小开

是的，记住每个递归方法调用的计算返回值非常重要，这样就可以在调用方法中显示序列。

在实施方面有一些改进，请参阅以下的实施方案，它使我们的产出更加正确和多样化:

import java.util.HashMap;
import java.util.stream.Collectors;


public class Fibonacci {
private static HashMap<Long, Long> map;


public static void main(String[] args) {
long n = 50;
map = new HashMap<>();
findFibonacciValue(n);
System.out.println(map.values().stream().collect(Collectors.toList()));
}


public static long findFibonacciValue(long number) {
if (number <= 1) {
if (number == 0) {
map.put(number, 0L);
return 0L;
}
map.put(number, 1L);
return 1L;
} else if (map.containsKey(number)) {
return map.get(number);
} else {
long fibonacciValue = findFibonacciValue(number - 1L) + findFibonacciValue(number - 2L);
map.put(number, fibonacciValue);
return fibonacciValue;
}
}
}

第50项的输出是:

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986, 102334155, 165580141, 267914296, 433494437, 701408733, 1134903170, 1836311903, 2971215073, 4807526976, 7778742049, 12586269025]

小开

使用 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;
}

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

小开

Fibbonacci 序列是一个求和的数字的结果然后我们在前面的结果中加上，我们应该从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);
}

小开

试试这个

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

小开

这是 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);
}

比奈的斐波那契数列公式用于上述实施。对于大输入，long可以替换为 BigDecimal。

小开

我找不到一个带有三元运算符的简单的一行程序，所以这里有一个:

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

Java 递归斐波那契数列

为什么这个答案不同

尾部递归纤维