केवल अग्रिम आदेश या क्रंमोत्तर चंक्रमण से एक BST के आंतरिक पथ लंबाई की गणना

अगर मैं आपकी समस्या को समझते हैं कि यह संभव नहीं हो सकता। दो पेड़ों पर विचार करें

   A         A
  / \        |
 B   C       B
             |
             C

ये वही अग्रिम आदेश ट्रावर्सल (एबीसी) लेकिन विभिन्न आंतरिक पथ की लंबाई (2 और 3) है।

वहाँ पर एक पेज है http://geeksforgeeks.org/?p=6633 कि traversals अपनी अग्रिम आदेश से और इन-क्रम एक पेड़ के निर्माण की चर्चा है। यहाँ, के बाद से अपने पेड़ एक खोज पेड़ है, तो आप में से आदेश ट्रावर्सल परोक्ष (का उपयोग करते हुए चाबियों का सॉर्ट क्रम) है। आप प्रत्येक पेड़ नोड के स्तर की गणना करने के उस साइट पर एक तरह पुनरावर्ती एल्गोरिदम का उपयोग कर सकते (पेड़ का निर्माण करने की जरूरत के बिना) तो आंतरिक पथ की लंबाई प्राप्त करने के लिए एक साथ स्तरों जोड़ें। यही कारण है कि एल्गोरिथ्म, सबसे कारगर नहीं हो सकता है, क्योंकि यह प्रत्येक नोड के दाईं बच्चे को खोजने के लिए ट्रेवर्सल पर खोजों करता है, लेकिन यह काम करना चाहिए। इस तरह एक भी पास एल्गोरिथ्म (यह मानते हुए सभी कुंजियों अलग हैं) करने के लिए पर मेरे सबसे अच्छे अनुमान है:

int internal_path_length(key_iter& cur_node, key_iter end, int level, key max_key) {
  if (cur_node == end) return 0;
  key cur_key = *cur_node;
  if (cur_key > max_key) return 0;
  ++cur_node;
  int len1 = internal_path_length(cur_node, end, level + 1, cur_key);
  int len2 = internal_path_length(cur_node, end, level + 1, max_key);
  return len1 + len2 + level;
}

के साथ शुरू:

key_iter i = preorder.begin();
internal_path_length(i, preorder.end(), 0, mk);

जहां mkअपने पेड़ में सबसे बड़ा संभव कुंजी से बड़ा है।

इसकी एक BST जब से हम परोक्ष (तत्वों के अनुसार क्रमबद्ध सूची) पेड़ की ट्रेवर्सल inorder किया है।

सिर्फ पूर्व के आदेश से हम एक अनूठा पेड़ बना सकते हैं या क्रंमोत्तर चंक्रमण पूर्व हो जाएगा [आर, तो आर कम तत्वों की सूची है, तो आर अधिक से अधिक तत्वों की सूची] पोस्ट किया जाएगा [कम आर तत्वों की सूची है, तो आर अधिक से अधिक तत्वों की सूची, आर]

छद्म कोड इस तरह दिखेगा।

findIPLPreOrder(poArray,startIndex,endIndex, height) {
     if(startIndex==endIndex){
          retrn height;
     }
     m=findIndexOfEndofLeftSubTree(poArray,start,end);
     return findIPLPreOrder(poArray,start+1,m,height + 1) + findIPLPreOrder(poArray,m+1,end,height + 1);     
}

findIndexOfEndofLeftSubTree(poArray,start,end){
  R=poArray[start]
  for(i=start+1;i<=end;i++){
     if(R < poArray[i]){
         return i-1;
       }
  }
}