Recursion Base Case and Recursive Case in DSA Typescript - Execution Trace

Concept Flow - Recursion Base Case and Recursive Case

Start: Call function

↓

Check base case condition

↓

Return base value

↓

Return

↓

Return result

The function checks if it reached the simplest case (base case). If yes, it returns a value. Otherwise, it calls itself with a smaller input and processes the result.

Execution Sample

DSA Typescript

function factorial(n: number): number {
  if (n === 0) return 1;
  return n * factorial(n - 1);
}

Calculates factorial of n using recursion with a base case at n=0.

Execution Table

Step	Operation	Input n	Condition (n === 0)?	Action	Return Value	Call Stack Depth
1	Call factorial(3)	3	No	Call factorial(2)		1
2	Call factorial(2)	2	No	Call factorial(1)		2
3	Call factorial(1)	1	No	Call factorial(0)		3
4	Call factorial(0)	0	Yes	Return 1	1	4
5	Return from factorial(1)	1	No	Calculate 1 * 1	1	3
6	Return from factorial(2)	2	No	Calculate 2 * 1	2	2
7	Return from factorial(3)	3	No	Calculate 3 * 2	6	1
8	Final return	3			6	0

💡 Recursion ends when n reaches 0, the base case, returning 1 and unwinding the calls.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6	After Step 7	Final
n	3	3	2	1	0	1	2	3	3
Return Value					1	1	2	6	6
Call Stack Depth	0	1	2	3	4	3	2	1	0

Key Moments - 3 Insights

Why does the recursion stop when n equals 0?

Because the base case condition (n === 0) is true at step 4 in the execution_table, the function returns 1 without further recursive calls, stopping the recursion.

What happens after the base case returns a value?

After the base case returns 1 at step 4, each previous call resumes and calculates its return value by multiplying n with the returned value, as shown in steps 5 to 7.

Why is the call stack depth important?

The call stack depth shows how many recursive calls are active. It grows until the base case (step 4) and then shrinks as calls return, visible in the variable_tracker.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what is the return value of factorial(0)?

A 0

B 1

C Undefined

D factorial(1)

💡 Hint

Check the 'Return Value' column at step 4 in the execution_table.

At which step does the recursion start to return back up the call stack?

A Step 3

B Step 4

C Step 5

D Step 7

💡 Hint

Look for the first step where a return value is calculated after the base case returns.

If the base case was changed to 'if (n === 1) return 1;', how would the call stack depth at step 4 change?

A It would be shallower

B It would be deeper

C It would be the same

D Recursion would never stop

💡 Hint

Changing the base case to n === 1 means recursion stops earlier, reducing call stack depth.

Concept Snapshot

Recursion has two parts:
- Base case: stops recursion (e.g., n === 0)
- Recursive case: calls itself with smaller input
Always ensure base case is reachable to avoid infinite calls.
Return values unwind back through calls.

Full Transcript

Recursion works by calling the same function inside itself with a smaller input until it reaches a base case. The base case stops further calls and returns a value. Then, each previous call uses that value to compute its own return value. This process is shown step-by-step in the execution table where factorial(3) calls factorial(2), then factorial(1), then factorial(0). At factorial(0), the base case returns 1. Then factorial(1) returns 1*1=1, factorial(2) returns 2*1=2, and factorial(3) returns 3*2=6. The call stack depth grows as calls go deeper and shrinks as they return. Understanding base and recursive cases is key to writing correct recursive functions.