Fibonacci Using Recursion in DSA Typescript - Execution Trace

Concept Flow - Fibonacci Using Recursion

Call fibonacci(n)

↓

Is n <= 1?

Yes→Return n

No↓

Call fibonacci(n-1)

↓

Call fibonacci(n-2)

↓

Add results of fibonacci(n-1) + fibonacci(n-2)

↓

Return sum

↓

End call for fibonacci(n)

The function calls itself with smaller numbers until it reaches 0 or 1, then returns and sums results back up.

Execution Sample

DSA Typescript

function fibonacci(n: number): number {
  if (n <= 1) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
}

console.log(fibonacci(4));

Calculates the 4th Fibonacci number by recursively summing previous two Fibonacci numbers.

Execution Table

Step	Call	Arguments	Return Value	Stack Depth	Action
1	fibonacci	4	?	1	Check if 4 <= 1 (No), call fibonacci(3) and fibonacci(2)
2	fibonacci	3	?	2	Check if 3 <= 1 (No), call fibonacci(2) and fibonacci(1)
3	fibonacci	2	?	3	Check if 2 <= 1 (No), call fibonacci(1) and fibonacci(0)
4	fibonacci	1	1	4	1 <= 1 (Yes), return 1
5	fibonacci	0	0	4	0 <= 1 (Yes), return 0
6	fibonacci	2	1	3	Return fibonacci(1)+fibonacci(0) = 1+0=1
7	fibonacci	1	1	3	1 <= 1 (Yes), return 1
8	fibonacci	3	2	2	Return fibonacci(2)+fibonacci(1) = 1+1=2
9	fibonacci	2	?	2	Check if 2 <= 1 (No), call fibonacci(1) and fibonacci(0)
10	fibonacci	1	1	3	1 <= 1 (Yes), return 1
11	fibonacci	0	0	3	0 <= 1 (Yes), return 0
12	fibonacci	2	1	2	Return fibonacci(1)+fibonacci(0) = 1+0=1
13	fibonacci	4	3	1	Return fibonacci(3)+fibonacci(2) = 2+1=3
14	-	-	-	-	End of recursion, final result is 3

💡 Recursion ends when calls reach n <= 1, returning n directly.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 6	After Step 8	After Step 12	Final
n	4	4	3	2	2	3	2	4
Return Value	-	?	?	?	1	2	1	3
Stack Depth	0	1	2	3	3	2	2	1

Key Moments - 3 Insights

Why does fibonacci(2) get called multiple times?

Because the function calls fibonacci(n-1) and fibonacci(n-2) separately each time without storing results, as seen in steps 3, 9, and 12 in the execution_table.

Why does the recursion stop at n <= 1?

Because the base case returns n directly when n is 0 or 1, stopping further recursive calls, shown in steps 4, 5, 7, 10, and 11.

What does stack depth represent in the variable_tracker?

It shows how many recursive calls are active at once, increasing when calling deeper and decreasing when returning, as seen increasing from 1 to 4 and then back down.

Visual Quiz - 3 Questions

Look at the execution_table, what is the return value of fibonacci(3) at step 8?

A 2

B 1

C 3

D 0

💡 Hint

Check the 'Return Value' column at step 8 for fibonacci(3).

At which step does the recursion first reach the base case?

A Step 2

B Step 6

C Step 4

D Step 9

💡 Hint

Look for the first step where 'Return Value' is directly n because n <= 1.

If we change the input to fibonacci(5), how would the stack depth change compared to fibonacci(4)?

A Maximum stack depth would stay the same

B Maximum stack depth would increase by 1

C Maximum stack depth would decrease

D Stack depth would be zero

💡 Hint

Stack depth increases with input size as recursion goes deeper, see variable_tracker for fibonacci(4).

Concept Snapshot

function fibonacci(n: number): number {
  if (n <= 1) return n;  // base case
  return fibonacci(n - 1) + fibonacci(n - 2);  // recursive calls
}

- Recursion stops when n is 0 or 1
- Each call waits for two smaller calls
- Results sum back up to final answer

Full Transcript

This visualization shows how the recursive Fibonacci function works step-by-step. The function calls itself with smaller numbers until it reaches the base case where n is 0 or 1, then returns that value. Each call waits for the results of fibonacci(n-1) and fibonacci(n-2), adds them, and returns the sum. The execution table tracks each call, its arguments, return values, and stack depth showing how recursion grows and shrinks. The variable tracker shows how n and return values change during execution. Key moments clarify why base cases stop recursion and why some calls repeat. The quiz tests understanding of return values, base cases, and recursion depth. This helps learners see recursion as a chain of calls building up and returning results.