在没有先验数字的情况下递归求解斐波那契数列

Question

有没有办法在没有任何信息的情况下打印斐波那契数列直到第 n 位？这是我这样做的一种方法，尽管它使用的是先验信息。

int p;
int n = 0;
String fib = "0, 1";

public printFib () {
    String fibSequence = fibPrint(0, 1, x); //x denotes xth fib number
    System.out.println(fibSequence);
}

private String logicFib (int a, int b, int c) {
    if (n == c-2) {
        return fib;
    } else {
        n++;
        p = a + b;
        fib = fib + ", " + p;
        logicFib(b, p, c);
    }
}

这里的问题是我在数字1, 2 上打印数字3, 4, 5, ... n，而我想在不先声明前两位数字的情况下打印它们。我的方法的逻辑只有在前两位数已知的情况下才有效，当我想放弃这个时。

Answer 1

我认为斐波那契的标准解决方案如下所示：

public class Fibonacci {

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

    public static void main(String...args){

        int n = 20;
        Fibonacci f = new Fibonacci();
        for(int i = 0; i < n; i++){
            System.out.println(f.fibo(i));
        }
    }
}

在递归方法中，您总是需要一个中断条件。在这种斐波那契方法的情况下，这将是您可以在上面识别的第 0 和第 1 斐波那契数。没有其他方法可以递归计算斐波那契数。您只需要中断条件。

如果您不需要方法的递归字符，您可以通过比内公式计算数字。更多详情请点击here。

编辑：

我改变了我的方法。它现在计数到第 n 个斐波那契数。

Answer 2

你知道限制，因为你必须知道要打印多少个数字。

public class Fibonacci {
    public int limit = 10;
    public int left=0, right=1;
    public int next;
    public void countNextFibo(int limit) {
        if(this.limit==0) {
            return;
        }
        else {
            System.out.print(left+", ");
            next = left+right;
            left = right;
            right = next;            
            --this.limit;
            countNextFibo(this.limit);
        }
    }

    public static void main(String args[]) {
        Fibonacci f = new Fibonacci();
        f.countNextFibo(10);
    }
}

Answer 3

此解决方案使用Iterator 接口。运行时，它会计算长期范围内的所有斐波那契数。接受的答案是双倍指数时间，因为每次通话都是O(n^2)。在我的计算机上将 n 更改为 93 以执行与我的程序相同的操作，它将花费几个小时来计算此代码在 0.09 秒内执行的相同列表。

import java.util.Iterator;
import java.util.NoSuchElementException;
import java.lang.IllegalArgumentException;

public class Fibonacci implements Iterable<Long>
{
    final int FIB_MAX_LONG_INDEX = 92; // highest index producing correct long 
    int fromIndex = 0;
    int toIndex = FIB_MAX_LONG_INDEX;

    public Fibonacci(int fromIndex, int toIndex)
    {
        if( fromIndex > toIndex )
            throw new IllegalArgumentException("toIndex must be same or greater than fromIndex");

        if( toIndex > FIB_MAX_LONG_INDEX )
            throw new IllegalArgumentException("toIndex must be lowe or equal to 92 to not overflow long");

        this.fromIndex = fromIndex;
        this.toIndex = toIndex;
    }

    public Fibonacci(){}

    private class FibonacciIterator implements Iterator<Long>
    {
        private long cur = 0, next = 1;
        private int index=0;

        public boolean hasNext()
        {
            return index <= toIndex;
        }

        public Long next()
        {
            if ( index > toIndex )
                throw new NoSuchElementException();

            long tmpCur;
            do {
                tmpCur = cur;
                cur = next;
                next +=tmpCur;
                index++;
            } while ( index <= fromIndex );

            return tmpCur;
        }

        public void remove()
        {
            throw new UnsupportedOperationException();
        }
    }

    public Iterator<Long> iterator()
    {
        return new FibonacciIterator();
    }

    public static void main (String[] args)
    {
        Fibonacci fib = new Fibonacci();
        for (long i : fib)
        {
            System.out.print( i + " ");
        }
        System.out.println();
    }
}

运行时的输出（我添加了一些换行符）：

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 20365011074 32951280099 53316291173 
86267571272 139583862445 225851433717 365435296162 
591286729879 956722026041 1548008755920 2504730781961
4052739537881 6557470319842 10610209857723 
17167680177565 27777890035288 44945570212853 
72723460248141 117669030460994 190392490709135 
308061521170129 498454011879264 806515533049393 
1304969544928657 2111485077978050 3416454622906707 
5527939700884757 8944394323791464 14472334024676221 
23416728348467685 37889062373143906 61305790721611591
99194853094755497 160500643816367088 
259695496911122585 420196140727489673 
679891637638612258 1100087778366101931 
1779979416004714189 2880067194370816120 
4660046610375530309 7540113804746346429 

但正如您所见，您几乎可以创建任何索引范围。以下循环超过 30 到 39 并最终打印 832040 1346269 2178309 3524578 5702887 9227465 14930352 24157817 39088169 63245986

Fibonacci fib = new Fibonacci(30, 39);
for( long i : fib) {
    System.out.print(i + " "); 
}