Java 打印斐波那契数列的结果
我知道斐波那契级数的编码是：Java 打印斐波那契数列的结果,java,fibonacci,Java,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));
int fib(int n)
{
if (n==0 || n==1) return n;
else return fib(n-1)+fib(n-2);
}
for (int i=0;i<4;i++){
System.out.prinntln(fib(i));
}
for（inti=0；iOk，所以我没有看到您希望保留递归
那么这个呢:
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）
之前打印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
不会跨越递归调用树，而只是一个调用序列。如前所述，我只看到如果通过添加布尔函数可以控制整个调用树的打印
这就是你想要的吗
无论如何，这里仍然是我的第一个答案（效率更高，并且可以更快地为您提供相同的输出）：
迭代计算斐波那契数，而不是递归计算
最简单的方法是使用数组fib[]。
用fib[0]=0，fib[1]=1初始化。
然后迭代i=2到n，其中fib[i]=fib[i-1]+fib[i-2]
这也很容易调整，所以不需要完整的数组，只需要存储两个变量
fib[i-1]，fib[i-2]
事实上，你可以使用这个迭代循环，然后再次使它成为一个递归循环，但是它的结构与你原来的斐波那契函数不同。你可以编写另一个方法void printFib（int n）
，然后使用这个循环来打印每个fib（n）
在这个方法中。一个返回值的方法实际上不应该打印任何东西。但是如果你像Zane说的那样迭代计算每个数字，你可以有一个void方法来计算和打印值。我看不到任何方法可以在递归斐波那契方法中打印值。一个关于斐波那契级数的简单例子
class Fibonacci {
public static void main(String args[]) {
fibonacciSeries(6);
}
static void fibonacciSeries(int num) {
int a = 0, b = 1, i, c;
for (i = 0; i <= num; i++) {
if (i <= 1) {
c = i;
} else {
c = a + b;
a = b;
b = c;
}
System.out.print(c);
if(i != num) {
System.out.print(",");
}
}
}
类斐波那契{
公共静态void main（字符串参数[]）{
斐波那契系列（6）；
}
静态void fibonacci系列（int num）{
int a=0，b=1，i，c；
对于（i=0；i在一行中写入斐波那契级数
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)));
}
}
公共类Fib{
公共静态void main（字符串[]args）{
对于（inti=1，f=0，n=0；nintsum=1；
int n1=0，n2=1；
对于（int i=0；i<10；i++）
{
if（i<1）
{
系统输出打印（一）；
系统输出打印（“”）；
}
否则，如果（i>1）
{
系统输出打印（总和）；
系统输出打印（“”）；
总和=n1+n2；
n1=n2；
n2=总和；
}
}
下面是一个简单的示例，用于打印每个计算：
int x = 1;
int a = 0;
int t;
while(true)
{
System.out.println(x);
t = x;
x = x + a;
a = t;
if (x > 30)
{
break;
}
}
这将打印以下内容：
1
1
2
3
5
8
13
21
这是小于30的斐波那契数列。我希望这是打印斐波那契数列的简单方法。
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;
}
}
}
斐波那契级数
这可能是很好的一个
public static void febonassi(int range, int pre, int nxt) {
System.out.println(pre);
if (nxt <= range)
febonassi(range, nxt, nxt + pre);
}
publicstaticvoidfebonassi（int-range，int-pre，int-nxt）{
系统输出打印项次（预处理）；
if（nxt我使用了大小为howManyDigit
的int数组
这是我用较少变量编写斐波那契级数的最好方法
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));
int[]数组=新的int[howManyDigit]；
对于（int i=0；i1）
数组[i]=数组[i-1]+数组[i-2]；
其他的
数组[i]=i；
}
System.out.println（array.toString（array））；
到目前为止，这是我对斐波那契序列得出的最有效、最快的方法：
斐波那契动态版本
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];
}
public static biginger getFibonacciDynamic（长n）{
BigInteger[]斐波那契=新的BigInteger[（int）n+（n==0？2:1）]；
斐波那契[0]=BigInteger.valueOf（0）；
斐波那契[1]=biginger.valueOf（1）；
对于（int i=2；i[EDIT1]
我修复了打印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
}
}
公共类主
{
公共静态int f（int n，布尔p，int level，final int deep）{
if（n<2）{
if（p | | level==deep）System.out.println（1）；
返回1；
}否则{
int res=f（n-1，真&正，级别+1，深度）+f（n-2，假，级别+1，深度）；
如果（p）{
系统输出打印项次（res）；
}
返回res；
}
}
公共静态void main（字符串[]args）{
int n=10；
f（n，真，0，n-1）；//递归打印
}
}
我可以在一个函数中完成，但丢失了数字N_0，如下所示：
我将其解释为调用递归函数时的堆栈：
因此，返回函数的值类似于此堆栈：
我们需要打印圆圈中的数字，所以我包含一个布尔参数
要做到这一点：
公共类主
{
公共静态int f（int n，布尔p）{
if（n<2）{
if（p）System.out.println（1）；
返回1；
}否则{
int res=f（n-1，真&假）+f（n-2，假）；
如果（p）{
系统输出打印项次（res）；
}
返回res；
}
}
公共静态void main（字符串[]args）{
系统输出打印项次（1）；
f（10，真）；//递归打印
}
}
结果非常漂亮：））
1 1 2 3 5 8 13
public static void febonassi(int range, int pre, int nxt) {
System.out.println(pre);
if (nxt <= range)
febonassi(range, nxt, nxt + pre);
}
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));
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];
}
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
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
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
}
}
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
}
}