Iteration ਬਨਾਮ ਰੀਕਰਜ਼ਨ — ਮੁਢਲੇ-ਮਥਾਵਟ ਕੀ ਹਨ?

Question

Accepted Answer

**Iteration** ਲੂਪਸ ਵਰਤਦਾ ਹੈ; **ਰੀਕਰਜ਼ਨ** self-calls ਵਰਤਦਾ ਹੈ। ਉਹ ਬਰਾਬਰ ਸ਼ਕਤੀਸ਼ਾਲੀ ਹਨ (ਜੋ ਕੁਝ ਤੁਸੀਂ ਇੱਕ ਨਾਲ ਕਰ ਸਕਦੇ ਹੋ ਉਹ ਤੁਸੀਂ ਦੂਸਰੇ ਨਾਲ ਕਰ ਸਕਦੇ ਹੋ), ਪਰ ਉਹ ਸ਼ਾਨਦਾਰਤਾ ਅਤੇ ਖਰਚ ਵਿੱਚ ਫਰਕ ਹਨ।

## ਸਾਈਡ ਬਾਈ ਸਾਈਡ

```python
# Iterative sum: constant extra space
def sum_iter(n):
    total = 0
    for i in range(1, n + 1):
        total += i        # accumulate in a loop
    return total

# Recursive sum: uses the call stack
def sum_rec(n):
    if n == 0:
        return 0
    return n + sum_rec(n - 1)
```

## Comparison

| ਪਹਿਲੂ | Iteration | Recursion |
|--------|-----------|----------|
| Memory | O(1) extra | O(depth) stack |
| Readability | ਲੀਨੀਅਰ ਕੰਮ ਲਈ ਬਹੁਤ ਚੰਗਾ | trees / divide-and-conquer ਲਈ ਬਹੁਤ ਚੰਗਾ |
| Risk | ਅਨੰਤ ਲੂਪ | stack overflow |
| Speed | ਆਮ ਤੌਰ 'ਤੇ ਤੇਜ਼ (ਕੋਈ call overhead ਨਹੀਂ) | call overhead ਪ੍ਰਤੀ frame |

## ਕਿਸ ਨੂੰ ਕਦੋਂ ਵਰਤਣਾ ਹੈ

- **Iteration** ਨੂੰ ਸਧਾਰਨ ਲੀਨੀਅਰ traversals ਅਤੇ ਜਦੋਂ stack depth ਬਹੁਤ ਵੱਡਾ ਹੋ ਸਕਦਾ ਹੈ ਤਾਂ ਵਰਤੋ।
- **Recursion** ਨੂੰ ਜਦੋਂ ਸਮੱਸਿਆ ਕੁਦਰਤੀ ਤੌਰ 'ਤੇ recursive ਹੈ (trees, graphs, backtracking) ਅਤੇ depth ਸੀਮਿਤ ਹੈ ਤਾਂ ਵਰਤੋ।

## Pitfalls

ਡੂੰਘਾ recursion stack overflow ਦਾ ਖਤਰਾ ਹੈ; hot recursive ਕੋਡ ਨੂੰ iteration ਵਿੱਚ ਤਬਦੀਲ ਕਰੋ (ਅਕਸਰ ਇੱਕ explicit stack ਨਾਲ) ਜਦੋਂ depth unbounded ਹੋ।

## ਇਹ ਮਾਇਨੇ ਕਯੂਂ ਰੱਖਦਾ ਹੈ

ਸਹੀ ਸ਼ੈਲੀ ਚੁਣਨਾ ਕੋਡ ਨੂੰ ਸਹੀ ਅਤੇ ਪੜ੍ਹਨਯੋਗ ਦੋਵਾਂ ਨੂੰ ਰੱਖਦਾ ਹੈ।

Recursion tree ਅਤੇ graph ਕੋਡ ਨੂੰ elegant ਬਣਾਉਂਦਾ ਹੈ, ਪਰ ਇਸ ਦੇ memory ਖਰਚ ਨੂੰ ਜਾਣ ਕੇ ਤੁਸੀਂ ਡੂੰਘੇ inputs 'ਤੇ ਕ੍ਰੈਸ਼ਾਂ ਤੋਂ ਬਚ ਸਕਦੇ ਹੋ।

ਇਹ trade-off ਨਿਰਣਾ ਬਿਲਕੁਲ ਉਹੀ ਹੈ ਜੋ ਇੰਟਰਵਿਊਅਰ ਜਾਂਚਦੇ ਹਨ ਜਦੋਂ ਉਹ ਤੁਹਾਨੂੰ "ਇਸ ਨੂੰ iterative ਨਾਲ ਤਬਦੀਲ ਕਰੋ" ਲਈ ਕਹਿੰਦੇ ਹਨ।

ਪਹਿਲੂ	Iteration	Recursion
Memory	O(1) extra	O(depth) stack
Readability	ਲੀਨੀਅਰ ਕੰਮ ਲਈ ਬਹੁਤ ਚੰਗਾ	trees / divide-and-conquer ਲਈ ਬਹੁਤ ਚੰਗਾ
Risk	ਅਨੰਤ ਲੂਪ	stack overflow
Speed	ਆਮ ਤੌਰ 'ਤੇ ਤੇਜ਼ (ਕੋਈ call overhead ਨਹੀਂ)	call overhead ਪ੍ਰਤੀ frame