Recursion in Python in Hindi – रिकर्शन क्या है?

Table of Contents

• 1. Recursion in Python in Hindi – रिकर्शन क्या है?
• 2. Introduction to Recursion – रिकर्शन का परिचय
• 3. Working of Recursive Functions – रिकर्सिव फंक्शन कैसे काम करते हैं
• 4. How Recursion Uses the Call Stack – रिकर्शन में कॉल स्टैक का इस्तेमाल
• 5. Recursive vs Iterative Approach – रिकर्सिव और इटरेटिव अप्रोच में अंतर
• 6. Advantages of Recursion – रिकर्शन के फायदे
• 7. Disadvantages of Recursion – रिकर्शन के नुकसान
• 8. Applications of Recursion in Python in Hindi
• 9. FAQs

Programming सीखते वक्त जब students पहली बार Recursion का नाम सुनते हैं, तो अक्सर यह concept थोड़ा confusing लगता है। लेकिन असल में Recursion एक बहुत simple और powerful idea पर based है — कोई भी function खुद को ही call कर सकता है, ताकि किसी बड़े problem को उसी problem के छोटे version में तोड़कर solve किया जा सके।

• आसान भाषा में कहें तो, Recursion एक ऐसी technique है जिसमें function अपने आप को बार-बार call करता है, जब तक कि एक तय की गई condition (base case) पूरी न हो जाए।

• Recursion का इस्तेमाल खासकर उन problems में किया जाता है जिन्हें natural तरीके से छोटे-छोटे similar sub-problems में तोड़ा जा सकता है, जैसे factorial निकालना, fibonacci series बनाना या किसी tree structure को traverse करना।

• Python में recursion को समझना इसलिए भी जरूरी है क्योंकि यह Data Structures और Algorithms (DSA) की foundation है — बिना recursion समझे trees, graphs और backtracking जैसे advanced topics समझना मुश्किल हो जाता है।

• Exams में भी Recursion से जुड़े सवाल बहुत common होते हैं, इसलिए इसे सिर्फ theory से नहीं बल्कि examples और diagrams से practically समझना जरूरी है।

Introduction to Recursion – रिकर्शन का परिचय

Recursion को समझने का सबसे आसान तरीका है इसे एक real-life example से जोड़ना। मान लीजिए आप एक line में खड़े हैं और आपको यह पता करना है कि आपसे आगे कितने लोग खड़े हैं। आप अपने ठीक आगे वाले व्यक्ति से पूछ सकते हैं "तुमसे आगे कितने लोग हैं?", और वह व्यक्ति फिर अपने आगे वाले से यही सवाल पूछेगा। यह chain तब तक चलती रहेगी जब तक कोई ऐसा व्यक्ति न मिल जाए जो line में सबसे आगे खड़ा हो — यही व्यक्ति base case होगा।

Python में Recursive Function वह function होता है जो अपने खुद के definition के अंदर खुद को call करता है।

def countdown(n):
    if n == 0:
        print("Done!")
    else:
        print(n)
        countdown(n - 1)

countdown(5)

ऊपर दिए गए example में countdown() function खुद को countdown(n - 1) की तरह call कर रहा है। यह तब तक चलता रहेगा जब तक n की value 0 नहीं हो जाती, और यही condition function को रुकने के लिए बताती है।

• हर recursive function में दो जरूरी हिस्से होते हैं — Base Case (जो function को रुकने की condition बताता है) और Recursive Case (जिसमें function खुद को दोबारा call करता है)।

• अगर किसी recursive function में base case ही न हो, तो वह function infinite बार खुद को call करता रहेगा, जिससे program crash हो जाएगा — इसे RecursionError: maximum recursion depth exceeded भी कहा जाता है।

Working of Recursive Functions – रिकर्सिव फंक्शन कैसे काम करते हैं

Recursive Functions की working को समझने के लिए factorial का example सबसे बेहतर है, क्योंकि factorial की definition ही खुद recursive nature की होती है — n! = n × (n-1)!

def factorial(n):
    if n == 0 or n == 1:      # Base Case
        return 1
    else:                     # Recursive Case
        return n * factorial(n - 1)

print(factorial(5))   # Output: 120

जब हम factorial(5) को call करते हैं, तो Python अंदर ही अंदर इस तरह काम करता है:

factorial(5) = 5 * factorial(4)
factorial(4) = 4 * factorial(3)
factorial(3) = 3 * factorial(2)
factorial(2) = 2 * factorial(1)
factorial(1) = 1   # Base Case पूरा हुआ

अब वापस calculation होगी:
factorial(2) = 2 * 1 = 2
factorial(3) = 3 * 2 = 6
factorial(4) = 4 * 6 = 24
factorial(5) = 5 * 24 = 120

यहाँ पर एक जरूरी बात समझनी है — function पहले अपने आप को बार-बार call करता चला जाता है (यह phase कहलाता है winding), और जब base case मिल जाता है, तब वह सारी calls वापस अपने-अपने result के साथ return होने लगती हैं (यह phase कहलाता है unwinding)।

SVG Diagram: Recursive Function का Winding और Unwinding

यह diagram दिखाता है कि factorial(5) पहले factorial(1) तक lगातार calls करता है (winding), और फिर base case मिलने के बाद हर call अपना result वापस लौटाते हुए final answer 120 तक पहुँचती है (unwinding)।

How Recursion Uses the Call Stack – रिकर्शन में कॉल स्टैक का इस्तेमाल

Recursion को अंदर से समझने के लिए Call Stack का concept जानना बहुत जरूरी है। जब भी कोई function call होता है, Python उस function की सारी information (जैसे उसके local variables और वह कहाँ तक execute हुआ है) एक special memory area में store करता है, जिसे Call Stack कहते हैं।

• जैसे ही कोई function दूसरा function call करता है (recursive function के case में खुद को ही), उस नए call की जानकारी stack के ऊपर एक नई entry (जिसे stack frame कहते हैं) के रूप में add हो जाती है।

• Stack हमेशा LIFO (Last In, First Out) तरीके से काम करता है — यानि जो call सबसे last में stack में गई थी, वही सबसे पहले complete होकर बाहर (pop) होगी।

• जब कोई function अपना काम पूरा करके return statement तक पहुँचता है, तो उसकी entry stack से हटा (pop) दी जाती है, और control वापस उस function के पास चला जाता है जिसने उसे call किया था।

• अगर recursion बहुत ज्यादा गहराई (depth) तक चला जाए और base case न मिले, तो stack पूरी तरह भर जाता है, जिससे RecursionError आता है — इसे Stack Overflow भी कहा जाता है।

SVG Diagram: Call Stack in Recursion

यह diagram दिखाता है कि factorial(5) से शुरू होकर हर recursive call stack के ऊपर एक नई frame जोड़ती है, और सबसे ऊपर वाली call (factorial(1)) सबसे पहले complete होकर stack से निकलती है — यही LIFO सिद्धांत है।

Recursive vs Iterative Approach – रिकर्सिव और इटरेटिव अप्रोच में अंतर

वही काम जो हम recursion से करते हैं, अक्सर एक साधारण loop (iteration) से भी किया जा सकता है। दोनों तरीकों को समझने के लिए factorial का ही example फिर से लेते हैं।

# Recursive Approach
def factorial_recursive(n):
    if n == 0 or n == 1:
        return 1
    return n * factorial_recursive(n - 1)

# Iterative Approach
def factorial_iterative(n):
    result = 1
    for i in range(2, n + 1):
        result *= i
    return result

print(factorial_recursive(5))   # Output: 120
print(factorial_iterative(5))   # Output: 120

दोनों functions एक ही result देते हैं, लेकिन इनकी working और memory इस्तेमाल करने का तरीका बिल्कुल अलग है। Recursive approach हर call के लिए एक नई stack frame बनाता है, जबकि Iterative approach सिर्फ एक ही loop के अंदर variable को update करता रहता है।

Advantages of Recursion – रिकर्शन के फायदे

• 1. Code छोटा और साफ होता है:
  कई complex problems, खासकर tree और graph से जुड़े, recursion में बहुत कम lines में solve हो जाते हैं।

• 2. Problem को समझना आसान होता है:
  Recursion उन problems के लिए natural fit होता है जो खुद recursive nature के होते हैं, जैसे factorial, fibonacci या tree traversal।

• 3. Divide and Conquer में उपयोगी:
  Merge Sort और Quick Sort जैसे algorithms recursion के बिना लिखना मुश्किल हो जाता है।

• 4. Backtracking Problems में जरूरी:
  Maze solving, N-Queens जैसे problems में recursion की मदद से हर possible path आसानी से explore किया जा सकता है।

Disadvantages of Recursion – रिकर्शन के नुकसान

• 1. ज्यादा Memory इस्तेमाल होती है:
  हर recursive call के लिए एक नई stack frame बनती है, जिससे memory usage बढ़ जाता है।

• 2. Stack Overflow का खतरा:
  अगर recursion बहुत ज्यादा गहराई तक जाए या base case गलत हो, तो program crash हो सकता है।

• 3. Debug करना मुश्किल हो सकता है:
  Recursive functions की working को trace करना beginners के लिए शुरुआत में confusing हो सकता है।

• 4. Performance पर असर:
  बार-बार function calls होने की वजह से recursion, iteration के मुकाबले थोड़ा slow हो सकता है।

Applications of Recursion in Python in Hindi

Recursion सिर्फ एक theoretical concept नहीं है, बल्कि इसका इस्तेमाल बहुत सारी real-world problems में होता है।

• Factorial और Fibonacci Series निकालना — यह सबसे common examples हैं जिनसे students recursion सीखना शुरू करते हैं।

• Tree और Graph Traversal — जैसे Binary Tree में हर node को visit करना, जहाँ हर sub-tree खुद एक छोटा tree होता है।

• Sorting Algorithms — Merge Sort और Quick Sort जैसे algorithms recursion के core principle "divide and conquer" पर based हैं।

• Backtracking Problems — Maze solving, Sudoku solver और N-Queens problem जैसे puzzles recursion से efficiently solve किए जाते हैं।

• File System Navigation — किसी folder के अंदर सारी sub-folders और files को ढूंढने के लिए भी recursion इस्तेमाल होता है, क्योंकि हर folder के अंदर फिर से folders हो सकते हैं।

नीचे दिया गया example दिखाता है कि Fibonacci Series recursion से कैसे निकाली जाती है:

def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

for i in range(7):
    print(fibonacci(i), end=" ")
# Output: 0 1 1 2 3 5 8

इस example में हर number अपने से पिछले दो numbers के sum से निकाला जाता है, और यही recursive definition है — fibonacci(n) = fibonacci(n-1) + fibonacci(n-2), जिसमें fibonacci(0) और fibonacci(1) base cases हैं।

FAQs