चर्चा की गई अवधारणाओं का दृश्य प्रतिनिधित्व नीचे दिए गए चित्र में दिखाया गया है:
यह मार्गदर्शिका नीचे उल्लिखित अनुभागों को कवर करके बाइनरी ट्री के सभी लीफ नोड्स को प्रिंट करने की प्रक्रिया बताती है:
- लीफ नोड्स की पहचान कैसे करें?
- जावास्क्रिप्ट में बाइनरी ट्री के सभी लीफ नोड्स को बाएँ से दाएँ कैसे प्रिंट करें?
- बोनस टिप: बाइनरी ट्री के लीफ नोड्स को दाएं से बाएं दिशा में प्रिंट करना
- निष्कर्ष
लीफ नोड्स की पहचान कैसे करें?
“ पत्ता 'नोड्स वे हैं जिनमें कोई चाइल्ड नोड नहीं है, या विशिष्ट रूप से कहें तो जिनमें ' ऊंचाई ' का ' 0 ”। यदि नोड में ' ऊंचाई ' से अधिक ' 0 ” तो वह नोड आंतरिक नोड या रूट नोड हो सकता है। “ पत्ता ” नोड्स को आमतौर पर उस मूल स्रोत की पहचान करने के लिए बैकट्रैक किया जाता है जहां से यह नोड उत्पन्न होता है। इसका उपयोग ज्यादातर किसी त्रुटि या समस्या का कारण खोजने के लिए खोज या त्रुटि-खोज एल्गोरिदम में किया जाता है।
जावास्क्रिप्ट में बाइनरी ट्री के सभी लीफ नोड्स को बाएँ से दाएँ कैसे प्रिंट करें?
दो दृष्टिकोण हैं' पुनरावर्ती ' और ' चलने का वांछित में दिए गए बाइनरी ट्री में उपलब्ध सभी लीफ नोड्स का चयन करने के लिए ' बाएं ' को ' सही ' दिशा। इन दृष्टिकोणों का व्यावहारिक कार्यान्वयन नीचे दिए गए अनुभागों में प्रदर्शित किया गया है:
- बाइनरी ट्री के सभी लीफ़ नोड्स को बाएँ से दाएँ पुनरावर्ती रूप से प्रिंट करें
- पुनरावृत्तीय दृष्टिकोण का उपयोग करके बाइनरी ट्री के सभी लीफ नोड्स को प्रिंट करें
विधि 1: बाइनरी ट्री के सभी लीफ नोड्स को बाएँ से दाएँ पुनरावर्ती रूप से प्रिंट करें
पुनरावर्ती दृष्टिकोण सभी नोड्स का चयन करता है गहराई-प्रथम खोज एल्गोरिदम वह तरीका जो पहले पूरे बाईं ओर के नोड्स को पार करता है, फिर मध्य नोड और अंत में दाईं ओर के नोड्स को पार करता है। यह ऑपरेशन प्रत्येक नोड के लिए पुनरावर्ती रूप से किया जाता है और जब आगे कोई ट्रैवर्सिंग नहीं होती है ' पत्ता 'नोड्स की पहचान हो जाती है। इस अवधारणा को बेहतर ढंग से समझने के लिए, नीचे दिए गए कोड स्निपेट पर जाएँ:
कक्षा नोड{
निर्माता ( )
{
यह . सामग्री = 0 ;
यह . बाएं = व्यर्थ ;
यह . सही = व्यर्थ ;
}
} ;
जहां डिस्प्लेलीफनोड्स = ( रूटनोड ) =>
{
अगर ( रूटनोड == व्यर्थ )
वापस करना ;
अगर ( रूटनोड. बाएं == व्यर्थ && रूटनोड. सही == व्यर्थ )
{
दस्तावेज़। लिखना ( रूटनोड. सामग्री + ' ' ) ;
वापस करना ;
}
अगर ( रूटनोड. बाएं != व्यर्थ )
डिस्प्लेलीफनोड्स ( रूटनोड. बाएं ) ;
अगर ( रूटनोड. सही != व्यर्थ )
डिस्प्लेलीफनोड्स ( रूटनोड. सही ) ;
}
नमूनानोड था = ( वैल ) =>
{
tempNode था = नया नोड ( ) ;
tempNode. सामग्री = वैल ;
tempNode. बाएं = व्यर्थ ;
tempNode. सही = व्यर्थ ;
वापस करना tempNode ;
}
रूटनोड था = provNode ( 3 ) ;
रूटनोड. बाएं = provNode ( 6 ) ;
रूटनोड. सही = provNode ( 9 ) ;
रूटनोड. बाएं . बाएं = provNode ( 12 ) ;
रूटनोड. बाएं . सही = provNode ( पंद्रह ) ;
रूटनोड. बाएं . सही . सही = provNode ( 24 ) ;
रूटनोड. सही . बाएं = provNode ( 18 ) ;
रूटनोड. सही . सही = provNode ( इक्कीस ) ;
डिस्प्लेलीफनोड्स ( रूटनोड ) ;
उपरोक्त कोड ब्लॉक का स्पष्टीकरण नीचे दिया गया है:
- सबसे पहले, एक क्लास बनाएं जिसका नाम है ' नोड ', जो एक नया नोड बनाता है और उसका मान ' पर सेट करता है 0 ”। संलग्न ' बाएं ' और ' सही 'साइड नोड्स को' पर सेट किया गया है व्यर्थ 'डिफ़ॉल्ट रूप से क्लास कंस्ट्रक्टर का उपयोग करके।
- अगला, परिभाषित करें ' डिस्प्लेलीफनोड्स() 'फ़ंक्शन जो' के एकल पैरामीटर को स्वीकार करता है रूटनोड ”। इस पैरामीट्रिक मान को बाइनरी ट्री के वर्तमान में चयनित नोड के रूप में माना जाता है।
- फ़ंक्शन के अंदर, ' अगर ' कथन का उपयोग यह जांचने के लिए किया जाता है कि क्या ' रूटनोड 'शून्य है या नहीं. के मामले में ' व्यर्थ उस नोड के लिए आगे का निष्पादन रुक गया। दूसरे मामले में, रूटनोड ' बाएं ' और ' सही 'साइड नोड्स की जाँच की जाती है' व्यर्थ ”। यदि दोनों शून्य हैं, तो उसका मान ' नोड ” छप जाता है.
- यदि “ बाएं ' या ' सही 'नोड 'शून्य' नहीं है, फिर नोड के उस तरफ को 'पर पास करें डिस्प्लेलीफनोड्स() 'पुनरावर्ती ऑपरेशन के लिए फ़ंक्शन।
- 'नाम का एक नया फ़ंक्शन परिभाषित करें प्रोवेनोड() ' जो ' के एकल पैरामीटर को स्वीकार करता है वैल ”। फ़ंक्शन के अंदर ' का एक नया उदाहरण बनाएं नोड 'वर्ग का नाम' tempNode ”। पैरामीट्रिक असाइन करें ' वैल 'वर्ग संपत्ति के मूल्य के रूप में' सामग्री ' और सेट करें ' बाएं ' और ' सही 'साइड नोड्स' व्यर्थ ' डिफ़ॉल्ट रूप से।
- अंत में, 'नाम का एक ऑब्जेक्ट बनाएं रूटनोड ' के लिए ' प्रोवेनोड() 'फ़ंक्शन करें और नोड मान को इस फ़ंक्शन पैरामीटर के रूप में पास करें। 'जोड़कर बाएँ और दाएँ पक्ष के नोड बनाएँ' बाएं ' और ' सही 'रूटनोड' वाले कीवर्ड और उसी फ़ंक्शन का उपयोग करके उन्हें मान निर्दिष्ट करें ' प्रोवेनोड() ”।
- “ बाएं ' का अर्थ है रूट नोड की बाईं स्थिति और ' बांया छोड़ा 'स्थिति का अर्थ है बाएँ से बाएँ वही दृष्टिकोण' के मामले में लागू किया जाता है सही ' और ' सही ”
- पेड़ को परिभाषित करने के बाद, 'रूटनोड' को 'के लिए तर्क के रूप में पास करें' डिस्प्लेलीडनोड्स() बनाए गए पेड़ के सभी लीफ नोड्स को चुनने और प्रिंट करने का कार्य।
संकलन के बाद उत्पन्न आउटपुट पुष्टि करता है कि प्रदान किए गए पेड़ का लीफ नोड पुनर्प्राप्त किया गया है और कंसोल पर मुद्रित किया गया है:
विधि 2: पुनरावृत्तीय दृष्टिकोण का उपयोग करके बाइनरी ट्री के सभी लीफ नोड्स को प्रिंट करें
“ चलने का 'दृष्टिकोण सबसे कुशल दृष्टिकोण है, यह' की अवधारणा का उपयोग करता है धकेलना ' और ' जल्दी से आना ' का चयन करने के लिए पत्ता 'नोड्स. इस दृष्टिकोण के मुख्य बिंदु या कार्य नीचे बताए गए हैं:
कक्षा नोड{
निर्माता ( कीमत )
{
यह . डेटा = कीमत ;
यह . बाएं = व्यर्थ ;
यह . सही = व्यर्थ ;
}
} ;
जहां डिस्प्लेलीफनोड्स = ( रूटनोड ) =>
{
अगर ( ! रूटनोड )
वापस करना ;
सूची दें = [ ] ;
सूची। धकेलना ( रूटनोड ) ;
जबकि ( सूची। लंबाई > 0 ) {
रूटनोड = सूची [ सूची। लंबाई - 1 ] ;
सूची। जल्दी से आना ( ) ;
अगर ( ! रूटनोड. बाएं && ! रूटनोड. सही )
दस्तावेज़। लिखना ( रूटनोड. डेटा + ' ' ) ;
अगर ( रूटनोड. सही )
सूची। धकेलना ( रूटनोड. सही ) ;
अगर ( रूटनोड. बाएं )
सूची। धकेलना ( रूटनोड. बाएं ) ;
}
}
रूटनोड था = नया नोड ( 3 ) ;
रूटनोड. बाएं = नया नोड ( 6 ) ;
रूटनोड. सही = नया नोड ( 9 ) ;
रूटनोड. बाएं . बाएं = नया नोड ( 12 ) ;
रूटनोड. बाएं . सही = नया नोड ( पंद्रह ) ;
रूटनोड. बाएं . सही . सही = नया नोड ( 24 ) ;
रूटनोड. सही . बाएं = नया नोड ( 18 ) ;
रूटनोड. सही . सही = नया नोड ( इक्कीस ) ;
डिस्प्लेलीफनोड्स ( रूटनोड ) ;
उपरोक्त कोड का स्पष्टीकरण नीचे लिखा गया है:
- सबसे पहले, एक ' बनाएं नोड ' वह वर्ग जो एकल पैरामीटर प्राप्त करता है ' कीमत ” जिसे नव निर्मित नोड के मान के रूप में सेट किया गया है, और बाएँ और दाएँ पक्ष को शून्य पर सेट किया गया है। जैसा कि उपरोक्त उदाहरण में किया गया है।
- अगला, एक फ़ंक्शन बनाएं ' डिस्प्लेलीफनोड्स() ' जो ' के एकल पैरामीटर को स्वीकार करता है रूटनोड ”। इस 'रूटनोड' को बाइनरी ट्री माना जाता है और सबसे पहले इसकी रिक्तता की जाँच की जाती है।
- यदि नोड खाली नहीं है, तो 'नाम वाली एक खाली सूची' सूची ' बनाया गया है और ' रूटनोड 'पैरामीटर को' का उपयोग करके इसमें डाला गया है धकेलना() ' तरीका।
- फिर ' जबकि() ' का उपयोग किया जाता है जो ' की लंबाई तक क्रियान्वित होता है सूची ”। लूप के अंदर, एक पेड़ के नीचे रहने वाला तत्व या ' सूची ' का उपयोग करके हटा दिया जाता है जल्दी से आना() ' तरीका।
- अब, 'का अस्तित्व बाएं ' और ' सही 'रूटनोड' के किनारों की जाँच की जाती है, और यदि दोनों पक्ष मौजूद नहीं हैं तो इसका मतलब है कि इसमें कोई चाइल्ड नोड नहीं है। फिर, यह नोड स्क्रीन पर प्रदर्शित होता है और लीफ नोड के रूप में पहचाना जाता है।
- यदि बाईं या दाईं ओर कोई नोड है तो इसका मतलब है कि इसमें बच्चे हैं। फिर उस ' बाएं ' और ' सही 'नोड को' में धकेल दिया जाता है सूची लीफ नोड खोजने के आगे के ऑपरेशन के लिए।
- अंत में, नोड मानों को 'के पैरामीटर के रूप में पास करके एक कस्टम बाइनरी ट्री बनाएं' नोड 'क्लास कंस्ट्रक्टर। निर्माण के बाद, पेड़ 'रूटनोड' को 'के लिए तर्क के रूप में पास करें' डिस्प्लेलीफनोड्स() ' समारोह।
संकलन के बाद उत्पन्न आउटपुट से पता चलता है कि प्रदान किए गए पेड़ के लीफ नोड्स मुद्रित हैं:
बोनस टिप: बाइनरी ट्री के लीफ नोड्स को दाएं से बाएं दिशा में प्रिंट करना
उन सभी लीफ नोड्स को पुनः प्राप्त करने के लिए जिनमें कोई चाइल्ड नोड नहीं है सही ' को ' बाएं दिशा में, पुनरावर्ती दृष्टिकोण अपनी सहजता के कारण सबसे अधिक अनुशंसित है। उदाहरण के लिए, उपरोक्त अनुभागों में चर्चा किए गए उसी पेड़ का उपयोग लीफ नोड को पुनः प्राप्त करने के लिए किया जाएगा, लेकिन ' सही ' तक ' बाएं 'दिशा, जैसा कि नीचे दिखाया गया है:
कक्षा नोड{
निर्माता ( कीमत )
{
यह . डेटा = कीमत ;
यह . बाएं = व्यर्थ ;
यह . सही = व्यर्थ ;
}
} ;
फ़ंक्शन डिस्प्लेलीफनोड्स ( जड़ )
{
अगर ( जड़ == व्यर्थ )
{
वापस करना ;
}
अगर ( जड़। बाएं == व्यर्थ && जड़। सही == व्यर्थ )
{
दस्तावेज़। लिखना ( जड़। डेटा + ' ' ) ;
वापस करना ;
}
अगर ( जड़। सही != व्यर्थ )
{
डिस्प्लेलीफनोड्स ( जड़। सही ) ;
}
अगर ( जड़। बाएं != व्यर्थ )
{
डिस्प्लेलीफनोड्स ( जड़। बाएं ) ;
}
}
रूटनोड था = नया नोड ( 3 ) ;
रूटनोड. बाएं = नया नोड ( 6 ) ;
रूटनोड. सही = नया नोड ( 9 ) ;
रूटनोड. बाएं . बाएं = नया नोड ( 12 ) ;
रूटनोड. बाएं . सही = नया नोड ( पंद्रह ) ;
रूटनोड. बाएं . सही . सही = नया नोड ( 24 ) ;
रूटनोड. सही . बाएं = नया नोड ( 18 ) ;
रूटनोड. सही . सही = नया नोड ( इक्कीस ) ;
डिस्प्लेलीफनोड्स ( रूटनोड ) ;
ऊपर बताया गया कोड इस प्रकार काम करता है:
- सबसे पहले, कक्षा ' नोड ” बनाया गया है जो उपरोक्त उदाहरणों में किए गए लिंक को पेड़ में एक नया नोड जोड़ने के लिए डिफ़ॉल्ट कंस्ट्रक्टर का उपयोग करता है।
- अगला, ' डिस्प्लेलीडनोड्स() 'फ़ंक्शन बनाया गया है जो' के एकल पैरामीटर को स्वीकार करता है रूटनोड ”। इस पैरामीटर की जाँच 'के लिए की जाती है' व्यर्थ 'के माध्यम से स्थिति' अगर ' कथन।
- यदि प्रदान किया गया नोड सत्य नहीं है, तो यह ' बाएं ' और ' सही 'साइड नोड्स की जाँच की जाती है' व्यर्थ ' स्थिति। यदि दोनों शून्य हैं, तो नोड को 'के रूप में पहचाना जाएगा' पत्ता 'नोड और वेबपेज पर मुद्रित।
- उसके बाद, 'पास करें सही ' और ' बाएं 'के नोड्स' रूटनोड ' तक ' डिस्प्लेलीफनोड्स() ' समारोह।
- का उपयोग करके उदाहरण बनाकर प्रत्येक नोड की स्थिति आवंटित करें नया 'कीवर्ड और' नोड() ” कंस्ट्रक्टर और कंस्ट्रक्टर पैरामीटर के रूप में स्थिति निर्दिष्ट करना।
- “ बाएं ' का अर्थ है रूट नोड की बाईं स्थिति और ' बांया छोड़ा “स्थिति का अर्थ है बायां या बायां। 'के मामले में भी यही दृष्टिकोण लागू किया जाता है' सही ' और ' सही ”।
- अंत में, 'पास करें रूटनोड 'के लिए एक तर्क के रूप में' डिस्प्लेलीफ़नोड() ' समारोह।
उत्पन्न आउटपुट से पता चलता है कि लीफ नोड्स दाएं से बाएं दिशा में मुद्रित होते हैं।
यह सब बाइनरी ट्री के सभी लीफ नोड्स को किसी भी वांछित दिशा में प्रिंट करने के बारे में है।
निष्कर्ष
बाइनरी ट्री के सभी लीफ नोड्स को प्रिंट करने के लिए, एक यादृच्छिक वर्ग बनाएं जो ट्री नोड्स को मान बनाता है और निर्दिष्ट करता है। इसके बाद, एक यादृच्छिक फ़ंक्शन बनाएं जो ऊपर से नीचे के पदानुक्रम में पेड़ के एकल नोड को स्वीकार करता है। इस फ़ंक्शन में एकाधिक शामिल हैं अगर 'ऐसी स्थितियाँ जो जाँचती हैं कि क्या' नोड 'खाली नहीं है और इसमें कोई नोड नहीं है' बाएं ' और ' सही 'दिशा, तो उस नोड को' माना जाता है पत्ता 'नोड और कंसोल पर प्रदर्शित होता है। इस गाइड में बाइनरी ट्री के सभी लीफ नोड्स को बाएँ से दाएँ या दाएँ से बाएँ दिशा में प्रिंट करने की प्रक्रिया समझाई गई है।