Why Recursion Exists and What Loops Cannot Express Cleanly in DSA Typescript - Quick Recap

Recall & Review

beginner

What is recursion in simple terms?

Recursion is when a function calls itself to solve smaller parts of a problem until it reaches a simple case it can solve directly.

beginner

Why do we need recursion when we already have loops?

Loops repeat actions but can't easily handle problems that break down into smaller similar problems, like tree traversals or factorial calculation. Recursion handles these naturally.

intermediate

Give an example of a problem that loops cannot express cleanly but recursion can.

Calculating factorial of a number or traversing a tree structure are easier with recursion because they involve repeating the same process on smaller parts.

beginner

What is a base case in recursion?

A base case is the simplest situation where the problem can be solved directly without further recursion. It stops the recursive calls.

intermediate

How does recursion help in expressing problems with nested or hierarchical data?

Recursion naturally follows the structure of nested data by calling itself on each smaller part, making code simpler and clearer than complex loops.

What stops a recursive function from calling itself forever?

A An error thrown manually

B A loop inside the function

C A timer that stops the function

D A base case that ends recursion

A base case is a condition where the function stops calling itself, preventing infinite recursion.

Which problem is easier to solve with recursion than with loops?

A Summing numbers from 1 to 10

B Traversing a tree structure

C Printing numbers 1 to 5

D Repeating a task 3 times

Tree traversal involves nested structures that recursion handles naturally, unlike simple loops.

What does recursion do that loops cannot do cleanly?

A Break a problem into smaller similar problems

B Repeat a fixed number of times

C Run faster

D Use less memory

Recursion breaks problems into smaller parts and solves them similarly, which loops struggle to express clearly.

What is the main role of the base case in recursion?

A To start the recursion

B To speed up the recursion

C To stop the recursion

D To call another function

The base case stops recursion by providing a simple answer without further calls.

Which of these is a recursive problem?

A Calculating factorial of a number

B Finding the largest number in a list

C Adding two numbers

D Printing a message

Factorial calculation naturally uses recursion by multiplying the number by factorial of smaller numbers.

Explain why recursion is useful for problems involving nested or hierarchical data.

Think about how a tree has branches inside branches.

Describe the difference between loops and recursion in solving repetitive problems.

Consider how factorial is calculated.

Practice

1. Why do we use recursion instead of loops in some problems?

easy

A. Because recursion can express problems with self-similar subproblems naturally

B. Because loops are slower than recursion in all cases

C. Because recursion uses less memory than loops always

D. Because loops cannot run more than 10 times

Solution

1. Step 1: Understand recursion's nature

   Recursion breaks a problem into smaller versions of itself, which loops cannot express naturally.

2. Step 2: Compare loops and recursion

   Loops repeat fixed steps but cannot easily handle problems defined by self-similar subproblems like tree traversals.

3. Final Answer:

   Because recursion can express problems with self-similar subproblems naturally -> Option A

4. Quick Check:

   Recursion = self-similar problem solving [OK]

Hint: Recursion fits problems breaking into smaller similar parts [OK]

Common Mistakes:

• Thinking loops are always faster
• Believing recursion always uses less memory
• Assuming loops cannot run many times

2. Which of the following is the correct syntax for a recursive function in TypeScript?

easy

A. function factorial(n: number): number { if (n == 0) return 0; else return n + factorial(n + 1); }

B. function factorial(n: number): number { while (n > 1) n = n - 1; return n; }

C. function factorial(n: number): number { for (let i = 1; i <= n; i++) return i; }

D. function factorial(n: number): number { if (n <= 1) return 1; else return n * factorial(n - 1); }

Solution

1. Step 1: Identify recursive call

   function factorial(n: number): number { if (n <= 1) return 1; else return n * factorial(n - 1); } calls factorial inside itself with n-1, which is recursion.

2. Step 2: Check base case correctness

   function factorial(n: number): number { if (n <= 1) return 1; else return n * factorial(n - 1); } returns 1 when n <= 1, preventing infinite calls.

3. Final Answer:

   function factorial(n: number): number { if (n <= 1) return 1; else return n * factorial(n - 1); } -> Option D

4. Quick Check:

   Recursive call with base case = function factorial(n: number): number { if (n <= 1) return 1; else return n * factorial(n - 1); } [OK]

Hint: Look for function calling itself with smaller input [OK]

Common Mistakes:

• Missing base case causing infinite recursion
• Using loops instead of recursive calls
• Incorrect base case values

3. What is the output of this TypeScript code?

function printNumbers(n: number): void {
  if (n === 0) return;
  printNumbers(n - 1);
  console.log(n);
}
printNumbers(3);

medium

A. 3 2 1

B. 1 2 3

C. 3 2 1 0

D. 0 1 2 3

Solution

1. Step 1: Trace recursive calls

   printNumbers(3) calls printNumbers(2), which calls printNumbers(1), then printNumbers(0) returns immediately.

2. Step 2: Understand console.log order

   After reaching base case, console.log prints n while unwinding: prints 1, then 2, then 3.

3. Final Answer:

   1 2 3 -> Option B

4. Quick Check:

   Recursion unwinds printing ascending numbers [OK]

Hint: Recursion prints after call, so output is ascending [OK]

Common Mistakes:

• Assuming print before recursive call prints descending
• Including 0 in output incorrectly
• Confusing order of prints

4. Identify the error in this recursive function and choose the fix:

function sumToN(n: number): number {
  return n + sumToN(n - 1);
}

medium

A. Add a base case to stop recursion when n <= 0

B. Change return to console.log to print values

C. Replace recursion with a for loop

D. Remove the parameter n

Solution

1. Step 1: Identify missing base case

   The function calls itself without stopping condition, causing infinite recursion.

2. Step 2: Add base case to stop recursion

   Adding if (n <= 0) return 0; stops recursion and returns correct sum.

3. Final Answer:

   Add a base case to stop recursion when n <= 0 -> Option A

4. Quick Check:

   Base case prevents infinite recursion [OK]

Hint: Always include base case to stop recursion [OK]

Common Mistakes:

• Forgetting base case causes stack overflow
• Changing return to console.log does not fix recursion
• Removing parameter breaks logic

5. You want to flatten a nested array of numbers like [1, [2, [3, 4], 5], 6] into a single array [1, 2, 3, 4, 5, 6]. Why is recursion a better choice than loops here?

hard

A. Because recursion uses less memory than loops for arrays

B. Because loops can only flatten arrays with one level of nesting

C. Because recursion naturally handles unknown levels of nesting by calling itself

D. Because loops cannot access array elements

Solution

1. Step 1: Understand nested structure

   The array has unknown depth of nested arrays, which loops alone cannot easily handle.

2. Step 2: Recursion handles unknown depth

   Recursion calls itself on nested arrays, flattening all levels naturally without complex loops.

3. Final Answer:

   Because recursion naturally handles unknown levels of nesting by calling itself -> Option C

4. Quick Check:

   Recursion = natural for unknown nested depth [OK]

Hint: Recursion handles unknown nested depth easily [OK]

Common Mistakes:

• Thinking loops can flatten any nested array easily
• Believing recursion always uses less memory
• Assuming loops cannot access array elements