Java 递归斐波那契码

我已经写了斐波那契级数如下。 我想知道下面是否是使用递归的正确方法，因为我认为我在循环斐波那契函数，每次循环的条件和I的递增值就像for循环一样

public class FibanocciSeriesImpl {
static int a,b,i,n;
    static
    {
        a=0; b=1;i=2;
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter the number of elements in the series");
        n=sc.nextInt();

    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("The fibnocci series is below");
        System.out.print(a+","+b);
        fibnocciImpl(a,b);
    }
    public static void fibnocciImpl(int a,int b)
    {
        int c=a+b;
        a=b;
        b=c;
        i++;
        System.out.print(","+c);
        if(i<n)
        fibnocciImpl(a,b);

    }
}

公共类FibanocciSeriesImpl{
静态int a，b，i，n；
静止的
{
a=0；b=1；i=2；
扫描仪sc=新的扫描仪（System.in）；
System.out.println（“输入系列中的元素数”）；
n=sc.nextInt（）；
}
公共静态void main（字符串[]args）{
//TODO自动生成的方法存根
System.out.println（“下面是fibnocci系列”）；
系统输出打印（a+“，”+b）；
fibroccimpl（a，b）；
}
公共静态无效FibNoccimpl（内部a、内部b）
{
INTC=a+b；
a=b；
b=c；
i++；
系统输出打印（“，”+c）；
如果（i斐波那契序列可以在两行代码中递归实现，如下所示：

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

公共静态长fib（int n）{
如果（n虽然这已经说过很多次了，但值得重复：递归计算斐波那契序列——根据定义，不使用，比如，-——需要指数时间（
O（1.6^n）
），这对于大的
n
（例如
n>40
）是不可行的

斐波那契序列也可以在线性时间内迭代计算：

public static long fib(int n) {
    long a = 0, b = 1;
    if (n <= 1) { return n; }
    for (int i = 2; i < n; ++i) {
        int tmp = b;
        b += a;
        a = tmp;
    }
    return b;
}

公共静态长fib（int n）{
长a=0，b=1；
if（n+；nij
<；指向N
[
>；将指针移到i
[>>+>+-]；添加j i
>>；移到t2
[>-]；将t2添加到j
<；移动到t1
[>>+>；移动到t3
[<+>>-]；将t3移动到t1和t2
使用动态规划实现斐波那契也是可能的，动态规划比递归规划效率更高

int fibonacci(int n) {

    int[] f = new int[n + 1];
    int i;

    f[0] = 1;
    f[1] = 2;

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

    return f[i - 2];
}

intfibonacci（intn）{
int[]f=新的int[n+1]；
int i；
f[0]=1；
f[1]=2；
对于（i=2；i

时间复杂度：O（n）
额外空间：O（n）
公共静态无效printFIBO（int n）{
System.out.println（n是的，它是递归的，不，它不是递归的。）

这是递归，因为您再次调用该函数，但您误用了递归；您只是用递归调用替换了循环

下面是一个简单的示例，将循环更改为递归：

for(int i = 0; i < 3; i++) {
    // do something
}

for（int i=0；i<3；i++）{
//做点什么
}

可以用

  i = 0; // global variable
           //so that it maintains the value during recursive function calls
    void func() {
        // do something
        if(i < 3)
            func();
        i++;
    }

i=0；//全局变量
//以便在递归函数调用期间保持该值
void func（）{
//做点什么
如果（i<3）
func（）；
i++；
}

但是好的递归是使用相同的函数来做一些有意义的事情

下面是备受喜爱的斐波那契数实现：

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

公共静态长fib（int n）{
如果（n您可以在递归中执行此操作，如：

int fib(int i){
if(i == 0 || i ==1) return n;
else return fib(i - 1) + fib(i-2);
}

但是更快的方法是使用您可以阅读的iterativ方法
举例如下：

这不是斐波那契序列递归函数的经典实现，但根据定义，因为你在调用函数本身，它是递归的。最简单的递归方式可能需要指数时间，但它也可以在线性时间递归实现。@marstran当然，我的意思是，c按定义计算（且无记忆）需要指数时间。以下是线性时间内无记忆的递归解（在Scala中，由于空间原因）：
def fibonacci（第一：Int，第二：Int，n:Int）=如果（n@marstran，nice，我知道这些简单的事实。我只是指出OP使用的部分递归函数需要指数时间。如果只使用最后两个值，就没有理由创建数组。两个局部变量就可以了。@paulboddington我同意你的观点，但这只是为了证明这种可能性对于OP，这不会编译。抱歉，伙计：（
printFIBO
返回void，这意味着您不应该从中返回某些内容。还有
System.out.print（字符串）
将字符串写入stdout，并返回void，这意味着——你猜到了——它不会返回。因此，你不能从不返回的函数返回一个不存在的值。不过非常接近！）虽然这段代码可以回答这个问题，但提供关于它如何和/或为什么解决问题的附加上下文将提高答案的长期价值。
public static long fib(int n) {
    if (n <= 1) return n;
    else return fib(n - 1) + fib(n - 2);
}

int fib(int i){
if(i == 0 || i ==1) return n;
else return fib(i - 1) + fib(i-2);
}