रिकर्सिव फंक्शन वह फंक्शन होता है जो अपने निष्पादन के दौरान स्वयं को कॉल करता है। यह समस्या को छोटे उप-समस्याओं में तोड़कर हल करता है।
आधारभूत संरचना
def recursive_function(parameters):
if base_case_condition: # बेस केस - रिकर्सन रोकने की शर्त
return base_value
else:
return recursive_operation(recursive_function(modified_parameters))
उदाहरण 1: फैक्टोरियल गणना
def factorial(n):
if n == 1: # बेस केस
return 1
else:
return n * factorial(n - 1) # रिकर्सिव कॉल
number = 9
print(f"{number} का फैक्टोरियल: {factorial(number)}")
आउटपुट
9 का फैक्टोरियल: 362880
चरण-दर-चरण निष्पादन:
factorial(9) = 9 * factorial(8)
= 9 * 8 * factorial(7)
= ...
= 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1
= 362880
उदाहरण 2: संख्या प्रिंट करना (आगे और पीछे)
def print_pattern(x):
if x < 1: # बेस केस
return
else:
print(x, end=" ") # पहले प्रिंट: 5 4 3 2 1
print_pattern(x - 1)
print(x, end=" ") # वापसी पर प्रिंट: 1 2 3 4 5
print_pattern(5)
आउटपुट
5 4 3 2 1 1 2 3 4 5
रिकर्सन के प्रकार
- डायरेक्ट रिकर्सन: फंक्शन स्वयं को सीधे कॉल करता है
- इनडायरेक्ट रिकर्सन: फंक्शन A, फंक्शन B को कॉल करता है जो A को कॉल करता है
- टेल रिकर्सन: रिकर्सिव कॉल फंक्शन का अंतिम ऑपरेशन होता है
महत्वपूर्ण सावधानियां
- बेस केस अनिवार्य है - इसके बिना अनंत रिकर्सन होगा
- स्टैक ओवरफ्लो: गहरी रिकर्सन से
RecursionErrorहो सकता है (डिफ़ॉल्ट सीमा ~1000) - प्रदर्शन: कुछ मामलों में इटरेटिव समाधान बेहतर होता है
इटरेटिव विकल्प (फैक्टोरियल)
def factorial_iterative(n):
result = 1
for i in range(1, n + 1):
result *= i
return result
निष्कर्ष: रिकर्सन ट्री ट्रैवर्सल, डिवाइड-एंड-कॉन्कर एल्गोरिदम, बैकट्रैकिंग जैसी समस्याओं के लिए सुंदर समाधान देता है।