Does anyone explain to me what the trace makes the Fibonacci code recursive in Java?

To understand the algorithm, we can start with the base cases and go up:

fibonacci(0) --> 0
fibonacci(1) --> 1

For fibonacci(2) we have to apply the part of else :

fibonacci(2) --> fibonacci(1) + fibonacci(0)

To calculate the sum, it is necessary to know the result of the two calls that, in the case of addition, are evaluated from left to right. Therefore we have the following sequence:

fibonacci(2)
--> fibonacci(1) + fibonacci(0)
--> 1 + fibonacci(0)
--> 1 + 0
--> 1

For fibonacci(3) :

fibonacci(3)
--> fibonacci(2) + fibonacci(1)
--> (fibonacci(1) + fibonacci(0)) + fibonacci(1)
--> (1 + fibonacci(0)) + fibonacci(1)
--> (1 + 0) + fibonacci(1)
--> 1 + fibonacci(1)
--> 1 + 1
--> 2

This last case you can see that fibonacci(1) is invoked twice. The higher the whole number, the more times the calculations will be repeated. (An optimization mode would save the result for later calculations ( "memoization" )).

The process is quite linear, first one function and then the other. There is no mix of stacks since the functions are not invoked simultaneously.

Doing an exercise of imagination, to calculate fibonacci(n) you do not need more than n levels of recursion, which is the same, no more than n "stackframes" . p>     

Suppose we enter the number 3.

Since it is not 0 nor 1 it passes to else {

Once inside the else we are sure that the result will be the sum of fibonacci(n-1) + fibonacci(n-2) , exemplifying with a diagram it could be as follows

--------? (3)

------ / ------ \

----? (2) ------? (1)

Where do we not know the result "?" but if the number we are going to enter, the first fibonacci of the diagram of the second line fibonacci(n-1) is executed, which is fibonacci(2) , since it is not 0 nor 1 passes to else where it will be executed again fibonacci(n-1) + fibonacci(n-2) , the diagram would fit us now like this

--------? (3)

------ / ------ \

----? (2) ------? (1)

- / ---- \

-? (1) ---? (0)

Executing the first fibonacci of the 3 line fibonacci(n-1) that is 2 - 1 = 1 fibonacci(1) , when executing it and being 1, we return n that is 1, then we know that returns fibonacci(1)

--------? (3)

------ / ------ \

----? (2) ------? (1)

- / ---- \

-1 (1) ---? (0)

When executing the second fibonnacci of the third line fibonacci(n-2) which is 2 - 2 = 0 fibonacci(0) will return 0, since it returns n and n

--------? (3)

------ / ------ \

----? (2) ------? (1)

- / ---- \

-1 (1) --- 0 (0)

Now we know that fibonacci(2) returns fibonacci(1) + fibonacci(0) which is 1 + 0 = 1

--------? (3)

------ / ------ \

---- 1 (2) ------? (1)

- / ---- \

-1 (1) ---? (0)

Pasamo to the second fibonacci of the second line we know that% co_of% = 1, then.

--------? (3)

------ / ------ \

---- 1 (2) ------ 1 (1)

- / ---- \

-1 (1) --- 0 (0)

Again we know that fibonacci(1) returns fibonacci(3) which is 1 + 1 =

-------- 2 (3)

------ / ------ \

---- 1 (2) ------ 1 (1)

- / ---- \

-1 (1) --- 0 (0)

But as they said it would be better to debugge or with simple prints you can serve

To see the trace by yourself you could use the java debugger or if you can not show in the console what you do:

public int fibonacci(int n) {

  if ((n == 0) || (n == 1)) // base cases
       System.out.println("Devuelvo +"n)
       return n;
    else
       System.out.println("Entro en el else con +"n)      
        // recursion step
      return fibonacci(n - 1) + fibonacci(n - 2);
}

Although you can use other methods for the fibonacci series

public class fibonacci
{
public static void main (String[] args)
{
int a=0,b=1,c,hasta,i;
cantidad=15; //indica la cantidad de numeros en la serie fibonacci


for(i=0;i<hasta;i++)
{
c=a+b;
a=b;
b=c;
System.out.print(" "+a);
}
}

}