Recursion vs Iteration When Each Wins in DSA Javascript - Build Both Approaches

Recursion vs Iteration: When Each Wins

📖 Scenario: Imagine you are organizing a treasure hunt game. You have a list of clues, and each clue leads to the next one. You want to find the final treasure by following all clues in order.You can either follow the clues step-by-step (iteration) or ask a friend to help by passing the clues one by one until the last clue is reached (recursion).

🎯 Goal: Build two ways to find the final treasure clue from a list of clues: one using iteration (loop) and one using recursion (function calling itself). Understand when each way is better.

📋 What You'll Learn

Create an array called clues with exact values: 'Start', 'Forest', 'River', 'Mountain', 'Treasure'

Create a variable called steps and set it to 0

Write a function called findTreasureIterative that uses a for loop to find the last clue in clues and counts steps

Write a function called findTreasureRecursive that uses recursion to find the last clue in clues and counts steps

Print the results of both functions and the number of steps taken

💡 Why This Matters

🌍 Real World

Recursion and iteration are ways to solve problems step-by-step or by breaking them into smaller parts. This helps in games, puzzles, and searching tasks.

💼 Career

Understanding when to use recursion or iteration is important for writing efficient code in software development, especially in algorithms and data processing.

1

Create the clues list

Create an array called clues with these exact values in order: 'Start', 'Forest', 'River', 'Mountain', 'Treasure'

DSA Javascript

// Create the clues array with exact values
// Your code here

Hint

Use square brackets [] to create an array and separate values with commas.

2

Create the steps counter

Create a variable called steps and set it to 0 to count how many clues you check

DSA Javascript

const clues = ['Start', 'Forest', 'River', 'Mountain', 'Treasure'];
// Create steps variable and set to 0
// Your code here

Hint

Use let to create a variable that can change later.

3

Write the iterative function

Write a function called findTreasureIterative that uses a for loop with variable i to go through clues. Inside the loop, increase steps by 1. Return the last clue found after the loop.

DSA Javascript

const clues = ['Start', 'Forest', 'River', 'Mountain', 'Treasure'];
let steps = 0;
// Write findTreasureIterative function using for loop
// Your code here

Hint

Use a for loop to count each clue and return the last one.

4

Write the recursive function and print results

Write a function called findTreasureRecursive that takes a parameter index. If index is the last position in clues, return that clue. Otherwise, increase steps by 1 and call findTreasureRecursive with index + 1. Then, print the results of findTreasureIterative(), steps after iteration, reset steps to 0, call findTreasureRecursive(0), and print steps after recursion.

DSA Javascript

const clues = ['Start', 'Forest', 'River', 'Mountain', 'Treasure'];
let steps = 0;
function findTreasureIterative() {
    for (let i = 0; i < clues.length; i++) {
        steps++;
    }
    return clues[clues.length - 1];
}
// Write findTreasureRecursive function
// Print results of both functions and steps
// Your code here

Hint

Remember recursion calls itself with the next index until the last clue is found.

Print results using console.log.

Practice

1. Which scenario is best suited for using recursion instead of iteration?

easy

A. When the problem requires simple repeated loops

B. When the problem can be divided into smaller similar subproblems

C. When you want to avoid function call overhead

D. When memory usage must be minimal

Solution

1. Step 1: Understand recursion use case

   Recursion works well when a problem can be broken down into smaller versions of itself, like tree traversals or factorial calculation.

2. Step 2: Compare with iteration scenarios

   Iteration is better for simple repeated tasks without nested subproblems, so recursion is preferred for divide-and-conquer problems.

3. Final Answer:

   When the problem can be divided into smaller similar subproblems -> Option B

4. Quick Check:

   Recursion fits divide-and-conquer = C [OK]

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

Common Mistakes:

• Thinking iteration is always faster
• Ignoring function call overhead in recursion
• Confusing simple loops with recursive problems

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

easy

A. function recurse(n) { while(n > 0) { n--; } return n; }

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

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

D. function recurse(n) { if(n > 0) { return n * recurse(n + 1); } else { return 1; } }

Solution

1. Step 1: Identify recursive call and base case

   function recurse(n) { if (n <= 0) return 0; return n + recurse(n - 1); } has a base case (n <= 0) and calls itself with a smaller argument (n - 1), which is correct recursion.

2. Step 2: Check other options for recursion errors

   function recurse(n) { while(n > 0) { n--; } return n; } uses a loop, not recursion. function recurse(n) { for(let i=0; i 0) { return n * recurse(n + 1); } else { return 1; } } calls recurse with n + 1, causing infinite recursion.

3. Final Answer:

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

4. Quick Check:

   Base case + smaller recursive call = B [OK]

Hint: Look for base case and smaller recursive call [OK]

Common Mistakes:

• Missing base case causing infinite recursion
• Using loops instead of recursive calls
• Increasing argument in recursive call causing stack overflow

3. What is the output of the following JavaScript code?

function factorial(n) {
  if (n === 0) return 1;
  return n * factorial(n - 1);
}
console.log(factorial(4));

medium

A. 24

B. 10

C. 16

D. Error

Solution

1. Step 1: Trace recursive calls for factorial(4)

   factorial(4) calls factorial(3), factorial(3) calls factorial(2), factorial(2) calls factorial(1), factorial(1) calls factorial(0) which returns 1.

2. Step 2: Calculate return values step-by-step

   factorial(1) = 1 * 1 = 1, factorial(2) = 2 * 1 = 2, factorial(3) = 3 * 2 = 6, factorial(4) = 4 * 6 = 24.

3. Final Answer:

   24 -> Option A

4. Quick Check:

   4! = 24 [OK]

Hint: Factorial n! = n * (n-1)! [OK]

Common Mistakes:

• Confusing factorial with sum
• Forgetting base case returns 1
• Miscomputing multiplication order

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

function sumTo(n) {
  if (n === 1) return 1;
  return n + sumTo(n);
}

medium

A. Change return to console.log

B. Add a base case for n === 0

C. Replace recursion with a for loop

D. Change sumTo(n) to sumTo(n - 1) in the return statement

Solution

1. Step 1: Analyze recursive call argument

   The function calls sumTo(n) again without changing n, causing infinite recursion and stack overflow.

2. Step 2: Fix recursive call to reduce problem size

   Changing sumTo(n) to sumTo(n - 1) reduces n each call, eventually reaching base case n === 1.

3. Final Answer:

   Change sumTo(n) to sumTo(n - 1) in the return statement -> Option D

4. Quick Check:

   Recursive call must reduce argument = A [OK]

Hint: Recursive calls must progress toward base case [OK]

Common Mistakes:

• Calling function with same argument causing infinite loop
• Missing or wrong base case
• Confusing recursion with iteration fixes

5. You want to process a large list of numbers to find their sum. Which approach is better and why?

hard

A. Iteration is better because it uses less memory and avoids stack overflow

B. Recursion is better because it is easier to write for large lists

C. Recursion with memoization is best for summing lists

D. Recursive function without base case is best for performance

Solution

1. Step 1: Consider recursion limits for large lists

   Recursion uses call stack for each call, which can cause stack overflow for large lists.

2. Step 2: Compare iteration benefits

   Iteration uses constant memory and avoids stack overflow, making it safer and more efficient for large data.

3. Final Answer:

   Iteration is better because it uses less memory and avoids stack overflow -> Option A

4. Quick Check:

   Iteration safer for large data = A [OK]

Hint: Use iteration for large data to avoid stack overflow [OK]

Common Mistakes:

• Assuming recursion always simpler for large data
• Ignoring stack overflow risk
• Misusing memoization for simple sums