एक बाइनरी ट्री को पीछे छोड़कर

Question

जब मैं रिकर्सिव फ़ंक्शंस की बात करता हूं तो मुझे निराशाजनक रूप से खो दिया जाता है। मुझे एक बाइनरी पेड़ को पार करने और विशिष्ट मानों के बीच एक नया नोड डालने के लिए एक पुनरावर्ती कार्य बनाने की आवश्यकता है। क्या मुझे अपने ट्रैवर्स फ़ंक्शन को दोबारा करने और इसे हर दूसरे फ़ंक्शन में संशोधित करने की आवश्यकता होगी जिसका मैं उपयोग करता हूं? क्या कोई ट्रैवर्स फ़ंक्शन का मूल्यांकन करेगा?

मुझे लगता है कि मेरा ट्रैवर्सिंग कोड ठीक है।

Node traverse (Node currentNode){ 
    if (!currentNode.left.equals(null)){ 
     traverse (currentNode.left); 
     return currentNode.left; 
    } 
    if (!currentNode.right.equals(null)){ 
     traverse (currentNode.right); 
     return currentNode.right; 
    } 
    return currentNode; 
} 

Answer 1

जब बाइनरी पेड़ की बात आती है, तो कई अलग-अलग प्रकार के ट्रैवर्सल होते हैं जिन्हें दोबारा किया जा सकता है। वे उस क्रम में लिखे गए हैं जिनके संदर्भ में उनका संदर्भ लिया गया है (एल = बाएं बच्चे, वी = उस नोड पर जाएं, आर = दायां बच्चा)।

• में आदेश ट्रावर्सल (LVR)
• क्रम उलटा ट्रेवर्सल (RVL)
• Preorder ट्रेवर्सल (VLR)
• क्रंमोत्तर चंक्रमण (LRV)

आपका कोड दिखाई देता है प्रदर्शन किया जाना है पोस्टऑर्डर ट्रैवर्सल विधि, लेकिन आपको कुछ चीजें मिश्रित हो रही हैं। सबसे पहले, नोड वह है जिसे आप पार करना चाहते हैं; डेटा वह है जिसे आप देखना चाहते हैं। दूसरा, आपके पास नोड को वापस करने का कोई कारण नहीं है, जिस तरह से इसे लागू किया गया है। आपका कोड किसी शर्त के बारे में कहने की अनुमति नहीं देता है, 'मैं इस विशेष डेटा की तलाश में हूं, क्या आपके पास श्री नोड @ 0xdeadbeef है?', जो कुछ प्रकार के अतिरिक्त खोज पैरामीटर के साथ मिलेगा।

एक अकादमिक बीएसटी ट्रैवर्सल नोड्स को ही प्रिंट करता है। यदि आप एक खोज कार्यक्षमता जोड़ना चाहते हैं, तो यह केवल एक और पैरामीटर है, साथ ही सही नोड के लिए अतिरिक्त जांच भी है।

यहाँ एक टुकड़ा है:

// Academic 

public void traverse (Node root){ // Each child of a tree is a root of its subtree. 
    if (root.left != null){ 
     traverse (root.left); 
    } 
    System.out.println(root.data); 
    if (root.right != null){ 
     traverse (root.right); 
    } 
} 

// Search with a valid node returned, assuming int 

public Node traverse (Node root, int data){ // What data are you looking for again? 
    if(root.data == data) { 
     return root; 
    } 
    if (root.left != null){ 
     return traverse (root.left, data); 
    } 
    if (root.right != null){ 
     return traverse (root.right, data); 
    } 
    return null; 
} 

Answer 2

एक पुनरावर्ती फ़ंक्शन एक संशोधित पैरामीटर, या समाप्ति (निकास) स्थिति के साथ स्वयं का मान देता है। जैसे, क्रमगुणित:

int factorial(int param) { 
    if (param > 1) { 
     return param * factorial(param -1); 
    } else { 
     return 1; 
    } 
} 

अपने कोड में, आप एक 'पार' लेकिन फिर परिणाम के साथ कुछ भी नहीं कहते हैं ... यदि वह मौजूद अपने पुनरावर्ती क्रिया समाप्त करता है, अपने अंतिम वापसी पहले छोड़ दिया बच्चे को हो जाएगा, अन्यथा पहला दायां बच्चा मौजूद है, अन्यथा रूट नोड।

कृपया इस बारे में अधिक जानकारी दें कि आपको पेड़ को पार करने की आवश्यकता क्यों है (यह भी सुनिश्चित नहीं है कि "फ़ंक्शन की प्रतिलिपि बनाएँ और इसे हर दूसरे फ़ंक्शन में संशोधित करें", फ़ंक्शन का पूरा विचार कोड-एक बार है -कॉल-कई)

Answer 3

ऐसा लगता है कि आप प्रीऑर्डर पद्धति में ट्रैवर्स कर रहे हैं, लेकिन मैं वास्तव में कुछ वास्तविक मूल्य के साथ अपने वर्तमान नोड की तुलना किए बिना वास्तव में पूरा करना चाहता हूं, जो परिभाषित करता है कि आप पहुंच गए हैं गंतव्य। मैं एक साधारण पेड़ को चित्रित करने और चरणों को देखने का सुझाव दूंगा। फिर इसे कोड में डालने का प्रयास करें।