Why Recursion Exists and What Loops Cannot Express Cleanly in DSA Javascript - Performance Analysis

Time Complexity: Why Recursion Exists and What Loops Cannot Express Cleanly

O(n)

Understanding Time Complexity

We want to understand why recursion is useful and how it compares to loops in terms of time cost.

What kind of repeated work does recursion do that loops might not express clearly?

Scenario Under Consideration

Analyze the time complexity of this recursive function that calculates factorial.

function factorial(n) {
  if (n <= 1) return 1;
  return n * factorial(n - 1);
}
    

This function calls itself to multiply numbers down to 1, calculating factorial.

Identify Repeating Operations

Look at what repeats in this recursive function.

• Primary operation: One multiplication and one recursive call per function call.
• How many times: Exactly n times, decreasing n by 1 each call until 1.

How Execution Grows With Input

Each call does a small fixed amount of work and calls itself once with a smaller number.

Input Size (n)	Approx. Operations
10	10 multiplications and calls
100	100 multiplications and calls
1000	1000 multiplications and calls

Pattern observation: The number of operations grows directly with n, so doubling n doubles work.

Final Time Complexity

Time Complexity: O(n)

This means the time to finish grows in a straight line with the input size.

Common Mistake

[X] Wrong: "Recursion always makes code slower than loops."

[OK] Correct: Both recursion and loops can do the same amount of work; recursion just expresses some problems more clearly, especially those with repeated branching or nested calls.

Interview Connect

Understanding recursion's time cost helps you explain why it's chosen for some problems and shows you can think about how code grows with input size.

Self-Check

"What if the factorial function used a loop instead of recursion? How would the time complexity change?"

Practice

1. Why do we use recursion instead of loops in some problems?
function factorial(n) { if (n === 0) return 1; return n * factorial(n - 1); }

easy

A. Loops are always slower than recursion.

B. Recursion can express problems with self-similar structure more naturally.

C. Recursion uses less memory than loops.

D. Loops cannot perform repeated actions.

Solution

1. Step 1: Understand recursion's purpose

   Recursion solves problems by breaking them into smaller similar problems, like factorial breaking n! into n * (n-1)!.

2. Step 2: Compare recursion and loops

   Loops repeat actions but do not naturally express self-similar or nested structures, which recursion handles clearly.

3. Final Answer:

   Recursion can express problems with self-similar structure more naturally. -> Option B

4. Quick Check:

   Recursion = natural for self-similar problems [OK]

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

Common Mistakes:

• Thinking loops are always slower
• Believing recursion uses less memory
• Assuming loops cannot repeat

2. Which of the following is the correct syntax to define a recursive function in JavaScript?

easy

A. function recurse(n) { for(let i=0; i

B. function recurse(n) { while(n > 0) recurse(n - 1); }

C. function recurse(n) { if (n > 0) return n; }

D. function recurse(n) { if (n <= 0) return; recurse(n - 1); }

Solution

1. Step 1: Identify recursive call structure

   function recurse(n) { if (n <= 0) return; recurse(n - 1); } calls itself with a smaller argument and has a base case to stop recursion.

2. Step 2: Check other options for recursion correctness

   The options using for or while loops include recursive calls but lack base cases, leading to infinite recursion. The option that returns n without a recursive call is not recursive.

3. Final Answer:

   function recurse(n) { if (n <= 0) return; recurse(n - 1); } -> Option D

4. Quick Check:

   Correct recursion has base case and self-call [OK]

Hint: Look for base case and self-call in function [OK]

Common Mistakes:

• Missing base case causing infinite recursion
• Using loops instead of recursion
• No recursive call inside function

3. What is the output of this recursive function?

function sumTo(n) { if (n === 0) return 0; return n + sumTo(n - 1); } console.log(sumTo(3));

medium

A. 6

B. 3

C. 0

D. Error

Solution

1. Step 1: Trace recursive calls

   sumTo(3) calls sumTo(2), sumTo(1), sumTo(0). sumTo(0) returns 0.

2. Step 2: Calculate return values

   sumTo(1) = 1 + 0 = 1, sumTo(2) = 2 + 1 = 3, sumTo(3) = 3 + 3 = 6.

3. Final Answer:

   6 -> Option A

4. Quick Check:

   Sum 1+2+3 = 6 [OK]

Hint: Add numbers down to zero recursively [OK]

Common Mistakes:

• Confusing base case return value
• Adding incorrectly during return
• Expecting loop output instead

4. Find the error in this recursive function that tries to calculate factorial:

function factorial(n) { if (n === 0) return 1; else return n * factorial(n); }

medium

A. Recursive call uses same argument causing infinite recursion

B. Return statement is missing

C. Should use a loop instead of recursion

D. Missing base case for n < 0

Solution

1. Step 1: Check recursive call argument

   The function calls factorial(n) again without reducing n, causing infinite recursion.

2. Step 2: Identify fix

   The recursive call should be factorial(n - 1) to move toward base case.

3. Final Answer:

   Recursive call uses same argument causing infinite recursion -> Option A

4. Quick Check:

   Recursive call must reduce argument [OK]

Hint: Ensure recursive call moves toward base case [OK]

Common Mistakes:

• Not reducing argument in recursive call
• Ignoring base case
• Confusing recursion with loops

5. Which problem below is best solved using recursion rather than loops because it involves nested self-similar structure?

hard

A. Calculating the sum of numbers from 1 to n

B. Finding the maximum value in a flat array

C. Traversing a directory tree to list all files and folders

D. Repeating a task 10 times

Solution

1. Step 1: Analyze problem structures

   Sum and max in flat arrays are simple linear tasks suited for loops.

2. Step 2: Identify nested self-similar structure

   Directory trees have folders inside folders, a nested structure best handled by recursion.

3. Final Answer:

   Traversing a directory tree to list all files and folders -> Option C

4. Quick Check:

   Nested structures = recursion best [OK]

Hint: Use recursion for nested or tree-like data [OK]

Common Mistakes:

• Using recursion for simple linear tasks
• Ignoring nested structure complexity
• Confusing repetition with recursion need