Question

我知道Fibonacci系列的编码是：

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

我想知道是否有一种方法，使用前面提到的代码，打印系列的先前结果，但既不使用void函数（只作为系列的打印机）或调用每个的fibonacci函数计算

我不想这样做

for (int i=0;i<4;i++){
     System.out.prinntln(fib(i));
}

Intead我想只调用一次这个函数，如下所示：

FIB（4）;

并且打印是：

0,1,1,2,3

当然使用递归

有什么想法吗？感谢

Answer 1

package Practice;

public class Fabonacci {

    public static void main(String[] args) 
    {
        int a,b,c;
        a=0;
        b=1;
        c=2;

        for(int i=1; i<=10; i++)
        {
            c=a+b;
            System.out.println(a);
            a=b;
            b=c;        
        }
    }
}

这将输出为：

0 1 1 2 3 5 8 13 21 34

Answer 2

好的，所以我没有看到你想保留递归。

那怎么样：

public class fib {

  static int fibonacci(int value, boolean printThis) {
    int result;
    if (value==0 || value==1) {
      result = value;
      if (printThis) {
        System.out.print(result);
        System.out.print(", ");
      }
    } else {
      if (printThis) {
        result =  fibonacci(value-1, true)+fibonacci(value-2, false);
        System.out.print(result);
        System.out.print(", ");
      } else {
        result = fibonacci(value-1, false)+fibonacci(value-2, false);
      }
    }
    return result;
  }

  public static void main(String []args) {
    fibonacci(7, true);
    System.out.println();
  }
}

我没有看到你可以不用布尔值printThis来控制只打印由两个值的递归产生的树的一个路径。为了使这一点更清楚，请看看如何以递归的方式为教师做这件事。

递归向后调用计算，因此faculty(n)之前调用faculty(n-1)。如果您想在faculty(n-1)之前打印faculty(n)的值，则需要在返回值之前进行打印，如下所示：

static int faculty(int v) {
  int result;
  if (v==0) {
    result = 1;
  } else {
    result = v*faculty(v-1);
  }
  System.out.print(result);
  System.out.print(", ");
  return result;
}

这将按升序为您提供值。我希望你可以原谅最后一个逗号，你需要定义一个额外的函数，如果你想摆脱这个没有控制它的布尔参数。

所以你看到你可以为没有布尔值的教师控制打印。

但这是因为faculty不会跨越递归调用树，而只是一个单一的调用序列。如前所述，我只看到你可以通过添加布尔函数来控制整个打印树。

那是你所追求的吗？

无论如何，这仍然是我的第一个答案（效率更高，并且会更快地为您提供相同的输出）：

迭代计算Fibonacci数而不是递归计算。

最简单的方法是使用数组fib []。初始化为fib [0] = 0，fib [1] = 1。然后迭代i = 2到n，其中fib [i] = fib [i-1] + fib [i-2]。

调整它也很容易，因此您不需要完整的数组，但只需要存储两个变量 fib [i-1]，fib [i-2]。

事实上，你可以采用这个迭代循环，然后再次使它成为递归循环，但它的结构与原始的斐波那契函数不同。

Answer 3

将Fibonacci系列写成一行。

   public class Fib {
        public static void main(String[] args) {
            for(int i=1,f=0,n=0; n<15; n++,System.out.println(i=(f+(f+i))-(f=f+i)));            
        }
    }

Answer 4

您可以编写另一种方法void printFib(int n)，然后使用循环在此方法中打印每个fib(n)。一个返回值的方法确实不应该打印任何东西。但是如果你像Zane所说的那样迭代地计算每个数字，你可以使用一个void方法来计算和打印这些值。我没有看到在递归Fibonacci方法中打印值的任何方法。

Answer 5

Fibonnaci系列的一个简单例子。

new SchemaUpdate(config).Execute(true, true);

输出：

0,1,1,2,3,5,8

Answer 6

我希望打印斐波纳契系列

的简便方法

Fibonacci系列

public class Fib
{
public static void main(String[] args)
{
int first=0,second=1;next;
System.out.prinf("%d %d ",first,second);
    for(int i=0;i<=10;i++)
    {
     next=first+second;
     first=second;
     second=next;
     System.out.printf("%d ",second);
       }
   }
}

输出

0 1 1 2 3 5 8 13 21 34 55 89

Answer 7

这可能很好......

 public static void febonassi(int range, int pre, int nxt) {
    System.out.println(pre);
    if (nxt <= range)
        febonassi(range, nxt, nxt + pre);
}

Answer 8

我使用了大小为howManyDigit的int数组。

这是我使用较少变量编写 Fibonacci系列的最佳方式

    int[] array = new int[howManyDigit];
    for(int i=0;i<howManyDigit;i++){
        if(i>1)
             array [i]=array [i-1]+array [i-2];
        else
            array [i]=i;
    }
    System.out.println(Arrays.toString(array));

Answer 9

到目前为止，这是我为Fibonacci序列提出的最有效，最快捷的方式：

FIBONACCI DYNAMIC VERSION

public static BigInteger getFibonacciDynamic(long n) {

    BigInteger[] fibonacci = new BigInteger[(int) n + (n == 0 ? 2 : 1)];
    fibonacci[0] = BigInteger.valueOf(0);
    fibonacci[1] = BigInteger.valueOf(1);

    for (int i = 2; i <= n; i++) {
        fibonacci[i] = fibonacci[i - 1].add(fibonacci[i - 2]);
    }

    return fibonacci[(int) n];
}

您可以通过这种方式为前1000个值运行它：

public static void main(String[] args) {

    int index = 0;
    while (index < 1000) {
        long time = System.currentTimeMillis();
        BigInteger value = getFibonacciDynamic(index);
        System.out.println("VALUE: " + value + " TOOK: " + (System.currentTimeMillis() - time) + "ms" + " OF INDEX: " + index);
        index++;
    }
}

并打印出来：

VALUE: 0 TOOK: 0ms OF INDEX: 0
VALUE: 1 TOOK: 0ms OF INDEX: 1
VALUE: 1 TOOK: 0ms OF INDEX: 2
VALUE: 2 TOOK: 0ms OF INDEX: 3
VALUE: 3 TOOK: 0ms OF INDEX: 4
VALUE: 5 TOOK: 0ms OF INDEX: 5
VALUE: 8 TOOK: 0ms OF INDEX: 6
VALUE: 13 TOOK: 0ms OF INDEX: 7
VALUE: 21 TOOK: 0ms OF INDEX: 8
VALUE: 34 TOOK: 0ms OF INDEX: 9
VALUE: 55 TOOK: 0ms OF INDEX: 10
VALUE: 89 TOOK: 0ms OF INDEX: 11
VALUE: 144 TOOK: 0ms OF INDEX: 12
VALUE: 233 TOOK: 0ms OF INDEX: 13
VALUE: 377 TOOK: 0ms OF INDEX: 14
VALUE: 610 TOOK: 0ms OF INDEX: 15
VALUE: 987 TOOK: 0ms OF INDEX: 16
VALUE: 1597 TOOK: 0ms OF INDEX: 17
VALUE: 2584 TOOK: 0ms OF INDEX: 18
VALUE: 4181 TOOK: 0ms OF INDEX: 19
VALUE: 6765 TOOK: 0ms OF INDEX: 20
... till index 1000 with always < 10ms for each value

如果在索引45处使用递归，则需要这么长时间：

FIBONACCI RECURSIVE

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

---- PRINT ----
VALUE: 1134903170 TOOK: 9991ms OF INDEX: 45

Answer 10

[EDIT1] https://www.jdoodle.com/iembed/v0/2N3
我修复了打印N_0的功能，这很酷：

public class Main
{
    public static int f(int n, boolean p, int level, final int deep) {
        if (n < 2) {
            if (p || level == deep) System.out.println(1);
            return 1;
        } else {
            int res = f(n-1, true && p, level + 1, deep) + f(n-2, false, level + 1, deep);
            if (p) {
                System.out.println(res);
            }
            return res;
        }
    }
    public static void main(String[] args) {
        int n = 10;
        f(n, true, 0, n-1); // print recursive
    }
}

我可以在一个函数中执行此操作，但是丢失了数字N_0，如下所示： https://onlinegdb.com/S1M0SuEPv
我会在调用它时像递归函数堆栈一样解释它：

因此return函数的值将类似于此堆栈：

我们需要将数字打印成圆圈，所以我包含一个布尔参数为此：

public class Main
{
    public static int f(int n, boolean p) {
        if (n < 2) {
            if (p) System.out.println(1);
            return 1;
        } else {
            int res = f(n-1, true && p) + f(n-2, false);
            if (p) {
                System.out.println(res);
            }
            return res;
        }
    }
    public static void main(String[] args) {
        System.out.println(1);
        f(10, true); // print recursive
    }
}

结果非常漂亮：））

1 1 2 3 5 8 13 21 34 55 89

Answer 11

int sum = 1;
int n1 = 0 , n2 = 1;

for(int i = 0; i < 10; i++)
{
    if(i < 1)
    {
        System.out.print(i);
        System.out.print(" ");
    }
    else if(i > 1)
    {
        System.out.print(sum);
        System.out.print(" ");
        sum = n1 + n2;
        n1 = n2;
        n2 = sum;
    }
}

打印斐波那契系列的结果

11 个答案: