மறுநுழைவு என்றால் என்ன?

Question

Accepted Answer

**மறுநுழைவு** என்பது ஒரு செயல்பாடு தன்னைத்தானே அழைத்துக் கொண்டு ஒரே பிரச்சனையின் சிறிய பதிப்பைத் தீர்ப்பதாகும். ஒவ்வொரு மறுநுழைவுக்கும் அதைத் **நிலைய வழக்கு** மற்றும் அடிப்படையை நோக்கி நகரும் **மறுநுழைவு வழக்கு** தேவை.

## கருத்து

ஒரு பிரச்சனையைச் சிறிய ஒத்த உபப்பிரச்சனைகளாகப் பிரிக்கவும். ஒவ்வொரு அழைப்பும் **call stack** இல் ஒரு சட்டகத்தைத் தள்ளுகிறது; வருதல் அவற்றைக் கெடுக்கிறது.

## எடுத்துக்காட்டு

```python
def factorial(n):
    if n <= 1:            # base case: stop recursing
        return 1
    return n * factorial(n - 1)   # recursive case: smaller problem

factorial(4)             # 4 * 3 * 2 * 1 -> 24
```

## சுவடு

```text
factorial(4)
= 4 * factorial(3)
= 4 * (3 * factorial(2))
= 4 * (3 * (2 * factorial(1)))
= 4 * 3 * 2 * 1 = 24
```

## சிக்கலான தன்மை

இங்கே **O(n)** நேரம் மற்றும் **O(n)** stack இடம் (ஒவ்வொரு அழைப்புக்கும் ஒரு சட்டகம்).

## பொறிகள்

- **நிலைய வழக்கு இல்லை** -> முடிவிலா மறுநுழைவு -> stack overflow.
- ஆழமான மறுநுழைவு stack ஐ சோர்க்கலாம்; சில மொழிகளில் tail-call optimization இல்லை.
- தொடர்ந்து உபப்பிரச்சனைகளை மீண்டும் கணக்கிடுவது அதிவேக நேரமாக இருக்கலாம் (memoization உடன் சரிசெய்யுங்கள்).

## ஏன் முக்கியமானது

மறுநுழைவு இயல்பாகவே தன்னை ஒத்த பிரச்சனைகளை - மரங்கள், வரைபடங்கள், பிரிக்க மற்றும் வெல்ல - வளையங்களை விட மிகவும் சுத்தமாக வெளிப்படுத்துகிறது.

இது merge sort, backtracking, மற்றும் dynamic programming இன் பின்னால் உள்ள மানসிக மாதிரி.

call stack ஐ புரிந்துகொள்வது உங்களை debugging மற்றும் நினைவகத்தைப் பற்றி சிந்திக்க சிறந்தவர் ஆக்குகிறது.