Java में रिकर्शन
n नाम का एक int लेने वाली मेथड down लिखें। अगर n 0 या उससे कम हो तो खाली return; से रुकें। नहीं तो n प्रिंट करें, फिर उसी मेथड से down(n - 1) कॉल करें। main से down(3); कॉल करें। स्क्रीन तीन लाइन दिखाए: 3, फिर 2, फिर 1। मेथड छोटे नंबर से खुद को कॉल करती रहती है जब तक रुकना श्रृंखला खत्म न करे। रुकने वाली यही आत्म-कॉल इस पेज का पाठ है।
खुद को कॉल करने वाली मेथड
स्कोप पेज पर mark एक बार चली और खत्म हुई। यहाँ down चलती है, फिर पहली कॉल पूरी खत्म होने से पहले नए आर्ग्युमेंट वाली दूसरी down शुरू करती है। हर कॉल का अपना n होता है। श्रृंखला तभी खत्म होती है जब कोई कॉल रुकने पर टकराए।
Ladder.java नाम की छोटी प्रोग्राम फ़ाइल बनाएँ। पहली लाइन का public class फ़ाइल नाम से मेल खाना चाहिए: public class Ladder। इस फ़ाइल में पुराना Gate या Sign क्लास नाम न छोड़ें; कंपाइलर क्लास नाम और फ़ाइल नाम का मेल चाहता है।
main के बाहर, फिर भी क्लास के ब्रेसेस के अंदर, static void down(int n) लिखें। इस पेज पर void रखें: हर कदम प्रिंट करता है और टाइप्ड return से कुछ लौटाने की ज़रूरत नहीं। रुकना बिना मान के return; इस्तेमाल करता है — केवल यही कॉल खत्म करता है। कंपाइल से पहले फ़ाइल सेव करें। पहला पूरा प्रोग्राम अगले बॉक्स में है।
down वाली Ladder.java
यह वह संस्करण है जिसे आप पहले कंपाइल करते हैं। main एक कॉल रखता है। down रुकना, प्रिंट और आत्म-कॉल रखता है।
public class Ladder {
public static void main(String[] args) {
down(3);
}
static void down(int n) {
if (n <= 0) {
return;
}
System.out.println(n);
down(n - 1);
}
}
जिस फ़ोल्डर में Ladder.java है वहाँ से javac Ladder.java चलाएँ। जब कोष्ठक, ब्रेसेस और सेमीकोलन मेल खाते हैं तो javac अपनी कोई लाइन नहीं लिखता। फिर java Ladder चलाएँ — java Ladder.java नहीं। दूसरी कमांड से .java अंत हटाएँ। ये दोनों कमांड Windows और macOS पर काम करती हैं। प्रोग्राम तीन लाइन प्रिंट करके रुकना चाहिए: 3, फिर 2, फिर 1। आपको टाइप करने के लिए नहीं पूछना चाहिए। अगर टर्मिनल कीबोर्ड इनपुट का इंतज़ार करे तो पुराने अभ्यास की nextLine कॉल अभी फ़ाइल में है। उसे हटाएँ और ऊपर की down(3); व down मेथड रखें।
रन को एक बार क्रम से देखें। Java main से शुरू होती है। कॉल down(3) n बराबर 3 के साथ प्रवेश करती है। यह 0 से बड़ा है, इसलिए मेथड 3 प्रिंट करती है, फिर down(2) कॉल करती है। दूसरी कॉल 2 प्रिंट करती है, फिर down(1) कॉल करती है। तीसरी 1 प्रिंट करती है, फिर down(0) कॉल करती है। 0 वाली कॉल n <= 0 पर टकराती है और बिना प्रिंट किए लौटती है। श्रृंखला खत्म। स्क्रीन तीन प्रिंटेड लाइन रखती है।
इन कॉल में से हर एक उसी मेथड टेक्स्ट से अलग पास है। पहला पास down(2) शुरू करने के बाद भी काम रखता है — अंदर की कॉल लौटने के बाद खत्म होना। आप चार अलग मेथड नाम नहीं लिखते। एक मेथड लिखते हैं और छोटे आर्ग्युमेंट को रुकने की ओर प्रगति ले जाने देते हैं।
अगर शुरुआत down(2); कर दें तो स्क्रीन 2 फिर 1 दिखाए। मेथड बॉडी वही रहती है; केवल पहला आर्ग्युमेंट बदलता है, इसलिए श्रृंखला छोटी होती है। down(4); से शुरू करने पर चार लाइन दिखनी चाहिए: 4, 3, 2, 1। फिर बॉडी नहीं बदलती; केवल main पहला मान चुनता है।
रुकना पहले रखें
रुकना प्रिंट और आत्म-कॉल से पहले जाँचना चाहिए। अगर पहले प्रिंट करें और कभी n न जाँचें, या हमेशा उसी मान से down(n) कॉल करें, तो प्रोग्राम खत्म नहीं होता। इस शुरुआती आकार पर if (n <= 0) ब्लॉक मेथड के ऊपर रखें।
public class Ladder {
public static void main(String[] args) {
down(2);
}
static void down(int n) {
if (n <= 0) {
return;
}
System.out.println(n);
down(n - 1);
}
}
फिर कंपाइल और चलाएँ: javac Ladder.java, फिर java Ladder। स्क्रीन 2 फिर 1 दिखाती है। जब n 0 पहुँचता है तो रुकना अभी भी श्रृंखला खत्म करता है। down(n - 1) की जगह down(n) लिखना वही संख्या बार-बार भेजता है। तब प्रोग्राम सिस्टम के रोकने तक चल सकता है। छोटा आर्ग्युमेंट विचार का हिस्सा है: हर कॉल रुकने की ओर बढ़नी चाहिए।
रुकने को निकास द्वार समझें। प्रिंट इस कदम का काम है। आत्म-कॉल अगला कदम है। द्वार न हो तो हर कदम अंतहीन दूसरा कदम खोलता है। अगला कदम वही n इस्तेमाल करे तो आप द्वार की ओर कभी नहीं चलते। दोनों गलतियाँ स्रोत में अलग दिखती हैं, लेकिन इस शुरुआती आकार पर दोनों साफ अंत से इनकार करती हैं।
स्क्रीन के पास कॉल श्रृंखला
उत्पन्न लाइनों के पास एक शुरुआती कॉल पढ़ें। हर पंक्ति अभी भी प्रिंट करने वाली down की एक यात्रा है।
📊 down call chain for down(3)
| कॉल | n का मान | स्क्रीन लाइन |
|---|---|---|
पहली down(3) |
3 |
3 |
फिर down(2) |
2 |
2 |
फिर down(1) |
1 |
1 |
फिर down(0) |
0 |
(कोई लाइन नहीं — रुकना) |
आम गलती रुकना छोड़ना है। तब हर कॉल प्रिंट करती है और फिर कॉल करती है — हमेशा। दूसरी गलती रिकर्सिव कॉल के बाद प्रिंट करना है, पहले नहीं। इस पेज पर प्रिंट पहले आता है, इसलिए स्क्रीन उल्टी गिनती करती है। अगर println को down(n - 1) के नीचे ले जाएँ तो लाइनों का क्रम बदलता है — यहाँ की उल्टी गिनती के लिए प्रिंट आत्म-कॉल के ऊपर रखें।
पिछले पेज का स्कोप अभी भी थोड़ा मायने रखता है: हर कॉल का n उसी कॉल का पैरामीटर है। बाहरी कॉल का n अंदर की कॉल चलने पर खुद नहीं लिखता। अंदर की कॉल का अलग n है। अंदर की कॉल लौटने पर बाहरी कॉल आत्म-कॉल के बाद की लाइन से जारी रहती है — और इस पेज पर वह बस मेथड का अंत है।
पुराना Gate डेमो जिसमें mark(4) हो वही फ़ाइल में रह सकता है और अगर main अभी भी mark कॉल करे तो स्क्रीन भ्रमित हो। इस पेज सीखते हुए main को down(3); या down(2); तक साफ रखें। down को main के ब्रेसेस के अंदर न रखें। मेथड क्लास के अंदर, main के पास बैठती हैं।
main में System.out.println("down"); लिखना शब्द down प्रिंट करता है। श्रृंखला शुरू नहीं करता। तीन उल्टी-गिनती लाइन चाहें तो down(3); रखें।
एक और आकार: रुकना कुछ नहीं प्रिंट करता
आपने देखा कि 0 वाली कॉल शांत लौटती है। शुरुआती मान 1 से भी अभ्यास कर सकते हैं। स्क्रीन एक लाइन दिखाए: 1। फिर अगली कॉल down(0) है जो रुकती है।
public class Ladder {
public static void main(String[] args) {
down(1);
}
static void down(int n) {
if (n <= 0) {
return;
}
System.out.println(n);
down(n - 1);
}
}
javac Ladder.java और java Ladder के बाद स्क्रीन एक लाइन दिखाती है: 1। वही मेथड बॉडी down(3), down(2) और down(1) को कवर करती है। केवल main में पहला आर्ग्युमेंट बदलता है। इस शुरुआती पेज के लिए काफी है। रिकर्शन से योग लौटाने जैसे गहरे विचार बाद के कोर्स के लिए; यहाँ लक्ष्य आत्म-कॉल, छोटा आर्ग्युमेंट और रुकना है।
अगर स्क्रीन कुछ भी न दिखाए तो जाँचें कि main अभी भी कुछ और कॉल तो नहीं कर रहा, या रुकने का टेस्ट गलत तो नहीं — उदाहरण if (n >= 0) सकारात्मक n से शुरू करने पर किसी भी प्रिंट से पहले रुक जाएगा। शांत निकास के रूप में n <= 0 रखें, और कम से कम एक लाइन दिखे इसलिए main में सकारात्मक शुरुआत रखें।
classes से पहले
आप down(int n) लिख सकते हैं, जब n 0 या कम हो तो रुक सकते हैं, n प्रिंट कर फिर down(n - 1) कॉल कर सकते हैं। main से एक कॉल पूरी श्रृंखला शुरू करती है। स्क्रीन उल्टी-गिनती लाइन दिखाती है। जो मेथड रुकने की ओर कभी न बढ़े वह खत्म नहीं होती। अगला पेज classes है; वहाँ आप इन static मेथड पेजों से आगे फील्ड वाले प्रकार बनाना शुरू करते हैं।
🧠 अपने ज्ञान की परीक्षा करें
अपने ज्ञान की परीक्षा करें
इस इंटरैक्टिव क्विज़ के साथ अपनी चुनौती लें और देखें कि आप विषय को कितनी अच्छी तरह समझते हैं
📝 निर्देश
- हर प्रश्न को ध्यान से पढ़ें
- हर प्रश्न के लिए सबसे अच्छा उत्तर चुनें
- आप जितनी बार चाहें क्विज़ दोबारा दे सकते हैं
- आपकी प्रगति शीर्ष पर दिखाई जाएगी