पुनरावृत्ति बनाम recursion — क्या trade-offs हैं?

Question

Accepted Answer

**पुनरावृत्ति** लूप का उपयोग करती है; **recursion** स्वयं-कॉल का उपयोग करता है। वे समान रूप से शक्तिशाली हैं (जो आप एक के साथ कर सकते हैं वह आप दूसरे के साथ कर सकते हैं), लेकिन वे स्पष्टता और लागत में भिन्न हैं।

## साथ-साथ

```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)
```

## तुलना

| पहलू | पुनरावृत्ति | recursion |
|--------|-----------|----------|
| मेमोरी | O(1) अतिरिक्त | O(depth) stack |
| पठनीयता | रैखिक कार्य के लिए बहुत अच्छा | पेड़ों / divide-and-conquer के लिए बहुत अच्छा |
| जोखिम | अनंत लूप | stack overflow |
| गति | आमतौर पर तेज़ (कोई कॉल overhead नहीं) | प्रति frame कॉल overhead |

## कौन सा कब उपयोग करें

- सरल रेखीय traversals और जब stack depth बड़ा हो सकता है तो **पुनरावृत्ति** का उपयोग करें।
- जब समस्या स्वाभाविक रूप से recursive हो (पेड़, graphs, backtracking) और depth सीमित हो तो **recursion** का उपयोग करें।

## नुकसान

गहरी recursion stack overflow का जोखिम रखती है; जब depth असीमित हो तो hot recursive code को पुनरावृत्ति में परिवर्तित करें (अक्सर एक explicit stack के साथ)।

## यह क्यों मायने रखता है

सही शैली चुनना कोड को सही और पठनीय दोनों रखता है।

Recursion पेड़ और graph कोड को सुरुचिपूर्ण बनाता है, लेकिन इसकी मेमोरी लागत जानने से आप गहरे इनपुट पर crashes से बच सकते हैं।

यह trade-off निर्णय बिलकुल वही है जो interviewers जांचते हैं जब वे आपसे "इसे iterative में परिवर्तित करें" कहते हैं।

पहलू	पुनरावृत्ति	recursion
मेमोरी	O(1) अतिरिक्त	O(depth) stack
पठनीयता	रैखिक कार्य के लिए बहुत अच्छा	पेड़ों / divide-and-conquer के लिए बहुत अच्छा
जोखिम	अनंत लूप	stack overflow
गति	आमतौर पर तेज़ (कोई कॉल overhead नहीं)	प्रति frame कॉल overhead