berekenen interne weglengte van een BST alleen van preorder en postorder traversal

Als ik begrijp uw probleem kan het niet mogelijk zijn. Denk aan de twee bomen

   A         A
  / \        |
 B   C       B
             |
             C

Deze hebben dezelfde preorder traversal (ABC) maar verschillende interne weglengte (2 en 3).

Er is een pagina op http://geeksforgeeks.org/?p=6633 dat bespreekt de bouw van een boom uit de preorder en in-order traversals. Hier, aangezien uw boom is een zoekboom, heb je de in-order traversal impliciet (met behulp van de sorteervolgorde van de toetsen). U kunt een recursieve algoritme zoals die te gebruiken op die site op het niveau van elke boom knooppunt te berekenen (zonder dat de boom op te bouwen), voeg dan de niveaus samen om de lengte interne pad te krijgen. Dat algoritme is misschien niet de meest efficiënte, omdat het zoekopdrachten doet op de traversal naar rechts kind van elk knooppunt te vinden, maar het zou moeten werken. Dit is mijn beste gok over hoe je een single-pass-algoritme (ervan uitgaande dat alle toetsen zijn te onderscheiden) doen:

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;
}

Beginnen met:

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

waarin mkis groter dan de grootst mogelijke sleutel in uw boom.

Sinds haar een BST hebben we impliciet hebben inorder traversal van de boom (gesorteerde lijst van elementen).

We kunnen een unieke boom maken op basis van slechts preorder of postorder traversal Pre zal zijn [R, de lijst van elementen minder dan R, de lijst van elementen groter dan R] bericht zal zijn [lijst van punten minder dan R, de lijst van elementen groter dan R, R]

Pseudo-code zal er zo uitzien.

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;
       }
  }
}