यह जांचने के लिए एल्गोरिथ्म कि क्या एक द्विआधारी वृक्ष एक खोज वृक्ष है और पूर्ण शाखाओं की गणना करता है

Question

मुझे यह देखने के लिए एक पुनरावर्ती एल्गोरिथ्म बनाने की जरूरत है कि क्या एक द्विआधारी वृक्ष एक द्विआधारी खोज वृक्ष है और साथ ही साथ यह भी मान लें कि एक वैश्विक मान्यता वाले चर के साथ कुल पूर्ण शाखाएं (बाएं और दाएं दोनों बच्चों के नोड वाले माता-पिता) हैं। यह मेरी डेटा संरचना वर्ग के लिए एक असाइनमेंट है।

अब तक मेरे पास है

void BST(tree T) {
   if (T == null) return
   if ( T.left and T.right) {
      if (T.left.data < T.data or T.right.data > T.data) {
        count = count + 1
        BST(T.left)
        BST(T.right)
      }
   }
}

लेकिन मैं वास्तव में यह पता नहीं लगा सकता। मुझे पता है कि यह एल्गोरिथ्म समस्या को हल नहीं करेगा क्योंकि यदि कथन सत्य नहीं है तो गिनती शून्य होगी।

किसी को भी इस पर मेरी मदद कर सकता है?

Comments

तुलना ऑपरेटर <को नोड्स पर कैसे परिभाषित किया जाता है?

— जो

क्या आप गणना की गणना करना चाहते हैं, भले ही यह बाइनरी सर्च ट्री न हो?

— जो

क्या आपके एल्गोरिथ्म को कुछ भी वापस करना है, जैसे कि trueया false?

— जो

हो सकता है कि आपको पहले दो अलग-अलग कार्यों को परिभाषित करने की कोशिश करनी चाहिए: एक यह जांचने के लिए कि क्या यह एक बीएसटी है और एक पूरी शाखाओं की गिनती के लिए। यह अधिक प्रबंधनीय होना चाहिए।

— sepp2k

@OghmaOsiris मुझे लगता है कि उन्होंने कहा कि क्योंकि प्रश्न मूल रूप से "यहाँ मेरा कोड है, मैं इसे कैसे काम करूं?" यदि कोड छद्म (ish) किस्म का नहीं था, तो यह निश्चित रूप से एक SO प्रश्न होगा।

— sepp2k

Answer 1

जैसा कि दूसरों ने पहले ही टिप्पणियों में संकेत दिया है, आपके पास वास्तव में दो असंबंधित कार्य हैं: परीक्षण करना कि क्या पेड़ एक खोज वृक्ष है, और पूर्ण शाखाओं की गिनती है। जब तक असाइनमेंट विशेष रूप से इसके लिए कॉल नहीं करता, मैं दो अलग-अलग फ़ंक्शन लिखूंगा।

आइए पहले पूरी शाखाओं की गणना करते हुए देखें। इसका मतलब है कि नोड्स की गिनती करना जिसमें एक बाएं बच्चे और एक दाएं बच्चे दोनों हैं। तो फिर तुम काउंटर (बढ़ाने के लिए की जरूरत है count = count + 1) जब दोनों T.leftऔर T.rightगैर-शून्य कर रहे हैं (नहीं T.left.dataऔर T.right.data: डेटा इस कार्य के लिए बात नहीं करता है)।

if (T.left and T.right) {
    count = count + 1

इसके अलावा, आपको बाएं सबट्री का पता लगाने की आवश्यकता है, भले ही सही सबट्री खाली हो, और आपको बाएं सबट्री का पता लगाने की जरूरत है, भले ही बाईं सबट्री खाली हो। तो देखो जहाँ आप पुनरावर्ती कॉल डालते हैं।

यह जांचने के लिए कि क्या पेड़ एक खोज पेड़ है, आपको डेटा मूल्यों का निरीक्षण करने की आवश्यकता है। आपको पहले से ही सही तुलना के करीब कुछ मिल गया है; बिलकुल ठीक नहीं। विभिन्न आकृतियों के साथ कुछ उदाहरण पेड़ लिखें (बहुत बड़ा नहीं, 2 से 5 नोड्स) और उन पर अपना एल्गोरिथ्म चलाकर देखें कि क्या होता है।

वैधता जांच के परिणाम को डालने के लिए आपको अभी भी कुछ जगह खोजने की आवश्यकता है। फिर से, यह देखें कि आपने पुनरावर्ती कॉल कहां रखा है (यदि आप केवल इस भाग को करते हैं, तो कई समाधान हैं, लेकिन इस स्तर पर चिंता न करें यदि आप केवल एक ही देखते हैं)।

अंत में, एक बार जब आप दोनों कार्यों को अलग-अलग लिखने में कामयाब हो जाते हैं, और आपने उन्हें कुछ उदाहरणों पर परीक्षण किया है, तो उन्हें ध्यान से एक साथ रखें (यदि असाइनमेंट द्वारा आवश्यक है)।

Comments

धन्यवाद, मैं सवाल को फिर से पढ़ता हूं और इसे अलग तरीकों से माना जाता था।

— ओघमाओसिरिस

Answer 2

इस तरह की चीजों में, अक्सर पीछे की ओर सोचना आसान होता है, इसलिए पहले विचार करें कि आपको क्या चाहिए। अपने विवरण से, आइए उन्हें सूचीबद्ध करें:

• प्रत्यावर्तन
• वैधता
• पूर्ण नोड्स की गणना

ठीक है, यह एक काफी छोटी सूची है, यह प्रबंधनीय होना चाहिए। चलो एक खाली विधि के साथ शुरू करते हैं और मैं वर्णन करूंगा कि क्या हो रहा है।

valid_bst () {
}

अब वैधता है। आप वैधता की जांच कैसे करते हैं? चैट में आपने कहा कि एक पेड़ वैध है "यदि ... सभी बचे बच्चे माता-पिता से कम हैं, और दाएं बच्चे माता-पिता से अधिक हैं।" मुझे यकीन है कि आप समानता की अनुमति देना चाहते हैं। वह होगा t.left.value <= t.value <= t.right.value।

valid_bst () {
    This node is valid if t.left.value <= t.value <= t.right.value
}

लेकिन क्या होगा अगर बच्चों में से एक गायब है? आपने जो कहा है, मुझे लगता है कि आप जानते हैं कि नोड अभी भी वैध है यदि कोई लापता है (या दोनों हैं)। चलो इसे जोड़ते हैं, थोड़ा पुनर्गठन करते हैं:

valid_bst () {
    This node is valid to the left if 
        there is no left child or 
        it is no greater than the current node.
    This node is valid to the right if 
        there is no right child or 
        it is no less than the current node.
    This node is valid overall if it is valid to the left and right.
}

ठीक है, अब हम जानते हैं कि क्या यह नोड वैध है। हम कैसे जांचें कि क्या पूरा पेड़ वैध है? यह एक सरणी में नहीं है, इसलिए हम शायद इसे रैखिक रूप से लूप नहीं कर सकते / नहीं करना चाहते। आपका असाइनमेंट जवाब देता है: पुनरावृत्ति। लेकिन हम पुनरावृत्ति का उपयोग करके उत्तर कैसे जमा करते हैं? हमारे पास जानकारी के तीन टुकड़े हैं, चाहे यह नोड मान्य है, और कॉल का परिणाम यह पूछ रहा है कि क्या बाएं और दाएं नोड्स वैध हैं। जाहिर है कि पेड़ केवल तभी वैध होगा जब वे तीनों सत्य होंगे।

valid_bst () {
    This node is valid to the left if 
        there is no left child or 
        it is no greater than the current node.
    This node is valid to the right if 
        there is no right child or 
        it is no less than the current node.
    This node is valid overall if it is valid to the left and right.
    Is the left child valid?
    Is the right child valid?
    This tree is only valid if this node and both its children are.
}

यदि आप ध्यान दे रहे हैं, तो हमें यह भी बताता है कि हमारे कार्य को वापस क्या चाहिए।

अब, हम गिनती को कैसे एकीकृत करते हैं? आप कहते हैं कि क्या मायने रखता है ("बाएं और दाएं बच्चे दोनों नोड्स के साथ एक मूल नोड"), और वास्तविक कोड में अनुवाद करना मुश्किल नहीं होना चाहिए। जांचें कि क्या वह शर्त संतुष्ट है और उचित रूप से काउंटर बढ़ाएं। बस याद रखें कि यह कहीं न कहीं है जहां यह हर बार सच हो जाएगा।

और निश्चित रूप से मैंने कुछ विवरण छोड़ दिए हैं जैसे कि पुनरावृत्ति रोकने की स्थिति और अशक्त के लिए जांच।

Answer 3

ऊपर मेरी तीन टिप्पणियाँ आपके कोड की समस्याओं के तीन संकेत हैं।

1. जब तक आप पहले से ही विशेष रूप से परिभाषित नहीं करते हैं कि एक तुलना ऑपरेटर को नोड डेटा प्रकार को कैसे संभालना चाहिए, सबसे अधिक संभावना है कि दो नोड्स की तुलना सीधे आप क्या चाहते हैं। उदाहरण के लिए, आपके पास जो संभवतया था वह नोड्स में संग्रहीत फ़ील्ड की तुलना करना थाnode1.value < node2.value
2. अभी, आप केवल गिनती में जोड़ रहे हैं यदि तीसरा ifसच है, क्या आप सुनिश्चित हैं कि आप क्या करना चाहते थे? वैसे, हो सकता है कि आप यह जांचना चाहें कि यदि आप जो चाहते हैं, वह कथन क्या है।
3. मेरा मानना ​​है कि यदि पेड़ एक मान्य बीएसटी है और असत्य है तो आप सच लौटना चाहते हैं। जिसका अर्थ है कि आपको आधार मामले में हमेशा सही या गलत लौटना होगा, और आपको अपने पुनरावर्ती कॉल के परिणामों को भी वापस करना चाहिए।

Comments

बिंदु एक के बारे में: यह छद्म कोड है, है ना? इसलिए जब तक इरादे पाठक को बताए जाते हैं, तब तक इस तरह से सामान को परिभाषित करने का कोई कारण नहीं है।

— sepp2k

@ sepp2k यह सच है, और मेरी टिप्पणी शायद छद्म कोड के लिए थोड़ी बहुत नाइट-पिकी है। मुझे लगता है कि मेरी बात यह है कि हमें यह समझने की जरूरत है कि दो नोड्स की तुलना करने का क्या मतलब है। आपका कहना यह है कि हमें पहले ही यह समझ लेना चाहिए कि निहितार्थ।

— जो

ठीक, बिल्कुल।

— sepp2k