Go Recursion Functions
Go Recursion Functions – Complete Guide with Examples
In Go (Golang), a function can call itself to solve a problem. This technique is called recursion.
Recursion is powerful and elegant, especially for problems that can be broken down into smaller sub-problems, such as factorials, Fibonacci series, tree traversal, and divide-and-conquer algorithms.
What Is Recursion in Go?
Recursion is a programming technique where a function calls itself until a base condition is met.
Two Key Parts of Recursion
Base Case – stops the recursion
Recursive Case – function calls itself
Without a base case, recursion causes infinite calls and crashes the program.
Basic Syntax of Recursive Function in Go
Simple Example: Printing Numbers
Output
- Function calls itself
- Stops when
n == 0
Example: Factorial Using Recursion
Factorial Formula
Go Code
Usage
Output
- Classic recursion example
- Clean and readable logic
Example: Fibonacci Series Using Recursion
Output for fibonacci(6)
Note: Recursive Fibonacci is slow for large values.
How Recursion Works (Call Stack)
For factorial(3):
- Each call waits for the next
- Stored in the call stack
Recursion vs Loop in Go
Loop Version (Factorial)
Comparison
| Feature | Recursion | Loop |
|---|---|---|
| Code readability | High | Medium |
| Memory usage | High | Low |
| Performance | Slower | Faster |
| Stack overflow risk | Yes | No |
Rule:
Use recursion when logic is naturally recursive; otherwise, prefer loops.
Tail Recursion in Go
Tail recursion occurs when the recursive call is the last operation.
Go does not guarantee tail-call optimization, so stack usage still applies.
Common Mistakes with Recursion
- Missing base case
- Infinite recursion
- Using recursion for simple loops
- Ignoring stack overflow risk
- Poor performance for large inputs
When to Use Recursion in Go
- Tree traversal
- Divide and conquer algorithms
- Mathematical problems
- Backtracking (DFS, permutations)
- Cleaner logic over loops
Best Practices for Recursion in Go
- Always define a base case
- Keep recursion depth small
- Prefer loops for performance
- Avoid recursion for large datasets
- Test edge cases carefully
Interview Questions: Go Recursion
1. What is recursion in Go?
A function calling itself to solve a problem.
2. Why is a base case important?
It stops infinite recursion.
3. Does Go support tail-call optimization?
No guarantee.
4. Recursion vs iteration – which is better?
Depends on the problem.
5. Can recursion cause stack overflow?
Yes, if depth is too large.
Summary
- Recursion means a function calls itself
- Requires a base case
- Useful for complex problems
- Can be memory-heavy
- Loops are faster for simple logic
Mastering recursion in Go will help you understand algorithms, problem-solving, and advanced coding patterns
