Recursion vs Iteration When Each Wins in DSA C - Visual Comparison

Concept Flow - Recursion vs Iteration When Each Wins

Start Problem

↓

Choose Approach

↓

Recursion

↓

Function calls

↓

Stack builds

↓

Base case?

↓

Return result

↓

Result

The flow shows choosing between recursion and iteration, how recursion uses function calls and stack, iteration uses loops and variables, both end when base condition or loop condition fails, then return result.

Execution Sample

DSA C

int factorial_recursive(int n) {
  if (n <= 1) return 1;
  return n * factorial_recursive(n - 1);
}

int factorial_iterative(int n) {
  int result = 1;
  for (int i = 2; i <= n; i++) result *= i;
  return result;
}

Calculates factorial of n using recursion and iteration.

Execution Table

Step	Operation	Call Stack / Loop Variable	Action	Result / Stack State
1	Call factorial_recursive(3)	Stack: factorial_recursive(3)	Check if n <= 1 (3 <= 1?)	No, proceed to recursive call
2	Call factorial_recursive(2)	Stack: factorial_recursive(3) -> factorial_recursive(2)	Check if n <= 1 (2 <= 1?)	No, proceed to recursive call
3	Call factorial_recursive(1)	Stack: factorial_recursive(3) -> factorial_recursive(2) -> factorial_recursive(1)	Check if n <= 1 (1 <= 1?)	Yes, return 1
4	Return from factorial_recursive(1)	Stack: factorial_recursive(3) -> factorial_recursive(2)	Return 1	Stack unwinds
5	Return from factorial_recursive(2)	Stack: factorial_recursive(3)	Return 2 * 1 = 2	Stack unwinds
6	Return from factorial_recursive(3)	Stack: empty	Return 3 * 2 = 6	Stack unwinds, final result 6
7	Start factorial_iterative(3)	i=2, result=1	Multiply result by i (1 * 2)	result=2
8	Loop iteration	i=3, result=2	Multiply result by i (2 * 3)	result=6
9	Loop ends	i=4 (condition i<=3 false)	Exit loop	Final result=6

💡 Recursion ends when base case n<=1 is true; iteration ends when loop condition i<=n is false.

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	After Step 8	After Step 9
n (recursive)	3	3	2	1	1	2	3	-	-	-
Call Stack	empty	factorial_recursive(3)	factorial_recursive(3)->factorial_recursive(2)	factorial_recursive(3)->factorial_recursive(2)->factorial_recursive(1)	factorial_recursive(3)->factorial_recursive(2)	factorial_recursive(3)	empty	-	-	-
i (iterative)	-	-	-	-	-	-	-	2	3	4
result (iterative)	-	-	-	-	-	-	-	1	2	6

Key Moments - 3 Insights

Why does recursion use a call stack while iteration uses variables?

Recursion calls itself repeatedly, each call waiting for the next to finish, so the system keeps track of each call in a stack (see steps 1-6). Iteration uses a loop with variables updated in place without extra calls (see steps 7-9).

When does recursion stop calling itself?

Recursion stops when the base case condition is true (n <= 1), as shown in step 3 where factorial_recursive(1) returns 1.

Why does iteration stop when i > n?

The loop condition i <= n controls iteration. When i becomes 4 (step 9), the condition fails and the loop exits.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what happens?

A The base case is true and recursion returns 1

B The loop starts with i=1

C The recursion calls factorial_recursive(4)

D The iteration multiplies result by 3

💡 Hint

Check the 'Action' and 'Result / Stack State' columns at step 3 in execution_table

At which step does the iteration loop end?

A Step 7

B Step 8

C Step 9

D Step 6

💡 Hint

Look for the step where the loop condition becomes false in execution_table

If n was 5, how would the call stack change compared to step 2?

A It would have more recursive calls before base case

B It would have fewer recursive calls

C It would be empty immediately

D It would not change

💡 Hint

Check variable_tracker for how n changes and how many calls are made before base case

Concept Snapshot

Recursion calls the same function repeatedly until a base case stops it.
Iteration uses loops to repeat actions until a condition fails.
Recursion uses a call stack to remember each call.
Iteration updates variables in place without extra calls.
Use recursion for problems naturally divided into subproblems.
Use iteration for simple repeated tasks with less memory overhead.

Full Transcript

This lesson compares recursion and iteration by tracing factorial calculation both ways. Recursion calls itself with decreasing n until n <= 1, building a call stack that unwinds to produce the result. Iteration uses a loop multiplying result by i from 2 to n. The execution table shows each recursive call and return, and each loop iteration. Variables like n, i, and result change step by step. Key moments explain why recursion needs a stack and stops at base case, and why iteration stops when loop condition fails. The quiz tests understanding of these steps. The snapshot summarizes when to use recursion or iteration.