我知道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
当然使用递归
有什么想法吗? 感谢
答案 0 :(得分:2)
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
答案 1 :(得分:1)
好的,所以我没有看到你想保留递归。
那怎么样:
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]。
事实上,你可以采用这个迭代循环,然后再次使它成为递归循环,但它的结构与原始的斐波那契函数不同。
答案 2 :(得分:1)
将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)));
}
}
答案 3 :(得分:0)
您可以编写另一种方法void printFib(int n)
,然后使用循环在此方法中打印每个fib(n)
。一个返回值的方法确实不应该打印任何东西。但是如果你像Zane所说的那样迭代地计算每个数字,你可以使用一个void方法来计算和打印这些值。我没有看到在递归Fibonacci方法中打印值的任何方法。
答案 4 :(得分:0)
Fibonnaci系列的一个简单例子。
new SchemaUpdate(config).Execute(true, true);
输出:
0,1,1,2,3,5,8
答案 5 :(得分:0)
我希望打印斐波纳契系列
的简便方法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
答案 6 :(得分:0)
这可能很好......
public static void febonassi(int range, int pre, int nxt) {
System.out.println(pre);
if (nxt <= range)
febonassi(range, nxt, nxt + pre);
}
答案 7 :(得分:0)
我使用了大小为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));
答案 8 :(得分:0)
到目前为止,这是我为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
答案 9 :(得分:0)
[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
答案 10 :(得分:-1)
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;
}
}