Programming में कई समस्याएँ ऐसी होती हैं जिन्हें छोटे-छोटे समान (Similar) भागों में विभाजित करके आसानी से हल किया जा सकता है। उदाहरण के लिए Factorial निकालना, Fibonacci Series बनाना, किसी Folder के अंदर मौजूद सभी Files को पढ़ना या Tree Data Structure को Traverse करना।
ऐसी समस्याओं को हल करने के लिए Python में Recursion का उपयोग किया जाता है।
Recursion एक ऐसी तकनीक है जिसमें कोई Function स्वयं (Self) को बार-बार Call करता है, जब तक कि एक निश्चित Condition पूरी न हो जाए। यह Condition Base Case कहलाती है। यदि Base Case न हो, तो Function अनंत बार Call होता रहेगा और अंत में RecursionError आ जाएगा।
जब कोई Function अपने ही Function को Call करता है, तो उसे Recursive Function कहते हैं और इस प्रक्रिया को Recursion कहा जाता है।
Recursion = Function स्वयं को Call करता है।
- Function स्वयं को Call करता है।
- प्रत्येक Recursive Function में Base Case होना आवश्यक है।
- Function धीरे-धीरे समस्या को छोटे भागों में विभाजित करता है।
- प्रत्येक Call Memory में Store होती है।
- सभी Calls पूर्ण होने के बाद परिणाम वापस मिलता है।
Recursion में दो मुख्य भाग होते हैं—
- Base Case
- Recursive Case
वह Condition जहाँ Function आगे स्वयं को Call करना बंद कर देता है।
वह भाग जहाँ Function स्वयं को फिर से Call करता है।
def function_name():
if condition:
return
function_name()
def display():
print("Hello")
display()
display()
यह Program कभी समाप्त नहीं होगा और अंत में Error देगा।
RecursionError:
maximum recursion depth exceeded
def display(n):
if n == 0:
return
print(n)
display(n - 1)
display(5)
Output
5
4
3
2
1
यदि Base Case न हो, तो Function हमेशा स्वयं को Call करता रहेगा।
def test():
test()
test()
यह Program कभी समाप्त नहीं होगा।
number = 5
fact = 1
for i in range(1, number + 1):
fact *= i
print(fact)
def factorial(n):
if n == 1:
return 1
return n * factorial(n - 1)
print(factorial(5))
Output
120
factorial(5)
↓
5 × factorial(4)
↓
4 × factorial(3)
↓
3 × factorial(2)
↓
2 × factorial(1)
↓
1
↓
120
def fibonacci(n):
if n <= 1:
return n
return fibonacci(n - 1) + fibonacci(n - 2)
for i in range(8):
print(fibonacci(i), end=" ")
Output
0 1 1 2 3 5 8 13
def total(n):
if n == 1:
return 1
return n + total(n - 1)
print(total(10))
Output
55
def reverse(n):
if n == 0:
return
print(n)
reverse(n - 1)
reverse(10)
def forward(n):
if n == 0:
return
forward(n - 1)
print(n)
forward(10)
जब Function स्वयं को Call करता है, तब प्रत्येक Function Call Memory के Call Stack में Store होती है।
जैसे-जैसे Base Case पूरा होता है, Stack से Function Calls एक-एक करके हटती जाती हैं।
display(3)
↓
display(2)
↓
display(1)
↓
display(0)
↓
Return
↓
display(1)
↓
display(2)
↓
display(3)
जब कोई Function सीधे स्वयं को Call करे।
def demo():
demo()
जब एक Function दूसरे Function को Call करे और दूसरा Function पहले Function को।
def A():
B()
def B():
A()
|
Recursion |
Loop |
|
Function स्वयं को Call करता है |
for या while का उपयोग होता है |
|
Call Stack उपयोग होती है |
Stack की आवश्यकता नहीं |
|
जटिल समस्याओं के लिए उपयुक्त |
सामान्य Iteration के लिए बेहतर |
|
Memory अधिक उपयोग करता है |
Memory कम उपयोग करता है |
|
धीमा हो सकता है |
सामान्यतः तेज़ |
- Code छोटा और साफ़ होता है।
- Tree एवं Graph जैसी समस्याओं के लिए उपयुक्त।
- Divide and Conquer Algorithms में उपयोगी।
- Mathematical Problems के लिए सरल समाधान।
- Memory अधिक उपयोग होती है।
- अधिक Recursive Calls से RecursionError आ सकता है।
- Loop की तुलना में Performance कम हो सकती है।
- Debugging अपेक्षाकृत कठिन हो सकती है।
def factorial(n):
if n == 1:
return 1
return n * factorial(n - 1)
print(factorial(6))
def reverse(n):
if n == 0:
return
print(n)
reverse(n - 1)
reverse(5)
def forward(n):
if n == 0:
return
forward(n - 1)
print(n)
forward(5)
def total(n):
if n == 1:
return 1
return n + total(n - 1)
print(total(5))
def fibonacci(n):
if n <= 1:
return n
return fibonacci(n - 1) + fibonacci(n - 2)
for i in range(10):
print(fibonacci(i), end=" ")
def test():
test()
test()
Error
RecursionError:
maximum recursion depth exceeded
- हमेशा Base Case लिखें।
- अनावश्यक Recursion से बचें।
- जहाँ Loop अधिक सरल हो, वहाँ Loop का उपयोग करें।
- Recursive Calls को कम रखें।
- बड़े Data के लिए Iterative Approach पर विचार करें।
परीक्षा की दृष्टि से महत्वपूर्ण तथ्य
- Recursive Function स्वयं को Call करता है।
- Base Case के बिना Recursion समाप्त नहीं होती।
- प्रत्येक Function Call Call Stack में Store होती है।
- Direct और Indirect Recursion दो प्रकार की होती हैं।
- Factorial और Fibonacci Recursion के लोकप्रिय उदाहरण हैं।
- अधिक Recursive Calls से RecursionError आ सकता है।
Frequently Asked Questions (FAQs)
जब कोई Function स्वयं को Call करता है, तो उसे Recursion कहते हैं।
वह Condition जहाँ Recursive Function स्वयं को Call करना बंद कर देता है।
Function Calls को अस्थायी रूप से Store करने वाली Memory Structure।
प्रश्न 4. Direct Recursion क्या है?
जब Function सीधे स्वयं को Call करे।
प्रश्न 5. Recursion और Loop में कौन बेहतर है?
सामान्य Iteration के लिए Loop अधिक तेज़ और Memory Efficient होता है, जबकि Recursive समस्याओं (जैसे Tree Traversal) के लिए Recursion अधिक उपयुक्त हो सकती है।
- Recursion → Function स्वयं को Call करता है।
- Base Case → Recursion रोकने की Condition।
- Recursive Case → स्वयं को दोबारा Call करना।
- Call Stack → Function Calls Store होती हैं।
- Direct Recursion → Function स्वयं को सीधे Call करे।
- Indirect Recursion → दो Functions एक-दूसरे को Call करें।
- RecursionError → Base Case न होने या अत्यधिक Recursive Calls पर।
Python Modules in Hindi – Module क्या है, Module बनाना, Import करना, import, from...import, as, Built-in Modules, User-defined Modules, dir(), help(), __name__ Variable और Practical Programs। यह Python के Modular Programming की शुरुआत है।
