Recursion vs Iteration When Each Wins in DSA Go - Complexity Comparison

Time Complexity: Recursion vs Iteration When Each Wins

O(n)

Understanding Time Complexity

We want to understand how recursion and iteration compare in time cost for solving problems.

Which method grows faster in work as input size increases?

Scenario Under Consideration

Analyze the time complexity of these two ways to sum numbers from 1 to n.

// Recursive sum
func recursiveSum(n int) int {
  if n == 0 {
    return 0
  }
  return n + recursiveSum(n-1)
}

// Iterative sum
func iterativeSum(n int) int {
  sum := 0
  for i := 1; i <= n; i++ {
    sum += i
  }
  return sum
}
    

Both functions add numbers from 1 to n but use different approaches.

Identify Repeating Operations

Look at what repeats in each method.

• Primary operation: Adding a number to the sum.
• How many times: Exactly n times in both recursion and iteration.

How Execution Grows With Input

As n grows, the number of additions grows the same way in both methods.

Input Size (n)	Approx. Operations
10	10 additions
100	100 additions
1000	1000 additions

Pattern observation: The work grows linearly with n in both cases.

Final Time Complexity

Time Complexity: O(n)

This means the time taken grows directly in proportion to the input size.

Common Mistake

[X] Wrong: "Recursion is always slower and less efficient than iteration."

[OK] Correct: Both can have the same time complexity; recursion may use more memory but not necessarily more time.

Interview Connect

Understanding when recursion or iteration is better helps you choose the right tool and explain your choice clearly in interviews.

Self-Check

"What if the recursive function uses memoization? How would that affect the time complexity?"

Practice

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

easy

A. When the problem can be divided into similar smaller problems

B. When you want to avoid function calls

C. When you need to use less memory

D. When the problem has a fixed number of steps

Solution

1. Step 1: Understand recursion use case

   Recursion works well when a problem can be broken down into smaller similar problems, like factorial or tree traversal.

2. Step 2: Compare with iteration

   Iteration is better for fixed steps or simple loops, but recursion shines in divide-and-conquer problems.

3. Final Answer:

   When the problem can be divided into similar smaller problems -> Option A

4. Quick Check:

   Recursion = divide and conquer [OK]

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

Common Mistakes:

• Thinking recursion always uses less memory
• Believing iteration is always faster
• Confusing fixed steps with recursive breakdown

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

easy

A. func factorial(n int) int { if n == 0 { return 0 } return n * factorial(n-1) }

B. func factorial(n int) { if n == 0 { return 1 } return n * factorial(n-1) }

C. func factorial(n int) int { for n > 0 { return n * factorial(n-1) } return 1 }

D. func factorial(n int) int { if n == 0 { return 1 } return n * factorial(n-1) }

Solution

1. Step 1: Check function signature and return type

   func factorial(n int) int { if n == 0 { return 1 } return n * factorial(n-1) } correctly defines factorial with int input and int return type.

2. Step 2: Verify base case and recursive call

   func factorial(n int) int { if n == 0 { return 1 } return n * factorial(n-1) } returns 1 when n is 0 and calls factorial(n-1) correctly.

3. Final Answer:

   func factorial(n int) int { if n == 0 { return 1 } return n * factorial(n-1) } -> Option D

4. Quick Check:

   Correct recursion syntax = func factorial(n int) int { if n == 0 { return 1 } return n * factorial(n-1) } [OK]

Hint: Look for correct return type and base case in recursion [OK]

Common Mistakes:

• Missing return type in function signature
• Incorrect base case return value
• Using loop inside recursive function incorrectly

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

import "fmt"

func sum(n int) int {
    if n == 0 {
        return 0
    }
    return n + sum(n-1)
}

func main() {
    fmt.Println(sum(3))
}

medium

A. Error

B. 6

C. 0

D. 3

Solution

1. Step 1: Trace recursive calls for sum(3)

   sum(3) = 3 + sum(2), sum(2) = 2 + sum(1), sum(1) = 1 + sum(0), sum(0) = 0.

2. Step 2: Calculate total sum

   sum(3) = 3 + 2 + 1 + 0 = 6.

3. Final Answer:

   6 -> Option B

4. Quick Check:

   Sum 1 to 3 = 6 [OK]

Hint: Add numbers down to zero recursively [OK]

Common Mistakes:

• Forgetting base case returns 0
• Adding instead of subtracting in recursion
• Expecting output 3 instead of sum

4. Identify the error in this iterative factorial function in Go and fix it:

func factorial(n int) int {
    result := 1
    for i := 1; i <= n; i++ {
        result = result + i
    }
    return result
}

medium

A. Initialize result to 0 instead of 1

B. Change loop to decrement i

C. Change '+' to '*' in result update

D. Add base case for n == 0

Solution

1. Step 1: Analyze the loop operation

   The loop adds i to result instead of multiplying, so it calculates sum not factorial.

2. Step 2: Fix the operation to multiplication

   Change 'result = result + i' to 'result = result * i' to compute factorial correctly.

3. Final Answer:

   Change '+' to '*' in result update -> Option C

4. Quick Check:

   Factorial uses multiplication, not addition [OK]

Hint: Factorial multiplies all numbers, not adds [OK]

Common Mistakes:

• Using addition instead of multiplication
• Not initializing result to 1
• Looping backwards unnecessarily

5. You want to process a large tree structure with unknown depth. Which approach is better and why?

Options:
A) Use iteration with an explicit stack to avoid stack overflow.
B) Use recursion for simplicity but risk stack overflow.
C) Use recursion with tail call optimization to save memory.
D) Use iteration with multiple nested loops for clarity.

hard

A. Use iteration with an explicit stack to avoid stack overflow.

B. Use recursion for simplicity but risk stack overflow.

C. Use recursion with tail call optimization to save memory.

D. Use iteration with multiple nested loops for clarity.

Solution

1. Step 1: Understand recursion limits on large unknown depth

   Recursion can cause stack overflow if the tree is very deep because each call uses stack memory.

2. Step 2: Use iteration with explicit stack to control memory

   Iteration with a manual stack simulates recursion but avoids system stack overflow, making it safer for large trees.

3. Final Answer:

   Use iteration with an explicit stack to avoid stack overflow. -> Option A

4. Quick Check:

   Iteration + explicit stack = safe deep tree traversal [OK]

Hint: Use iteration with stack to handle deep recursion safely [OK]

Common Mistakes:

• Assuming recursion always safe for deep trees
• Believing Go supports tail call optimization
• Using nested loops for unknown depth structures