calcular la longitud de la ruta interna de un BST sólo de orden previo o recorrido postorden

Si entiendo su problema puede que no sea posible. Considere los dos árboles

   A         A
  / \        |
 B   C       B
             |
             C

Estos tienen el mismo recorrido en preorden (ABC), pero diferentes longitudes de trayectoria internas (2 y 3).

Hay una página en http://geeksforgeeks.org/?p=6633 que trata sobre la construcción de un árbol de su orden previo y en orden recorridos. Aquí, dado que su árbol es un árbol de búsqueda, usted tiene el recorrido en orden implícita (usando el criterio de ordenación de las claves). Puede utilizar un algoritmo recursivo como el que en ese sitio para calcular el nivel de cada nodo del árbol (sin necesidad de construir el árbol), a continuación, añadir los niveles en conjunto para obtener la longitud del camino interno. Ese algoritmo puede no ser la más eficiente, ya que hace búsquedas en el recorrido para encontrar el hijo derecho de cada nodo, pero debería funcionar. Este es mi mejor conjetura acerca de cómo hacer un algoritmo de paso único (suponiendo que todas las claves son distintas):

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

Empezar con:

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

donde mkes más grande que la clave más grande posible en su árbol.

Ya que es un BST hemos tienen implícitamente finde recorrido del árbol (lista ordenada de elementos).

Podemos crear un árbol único de sólo pre-ordenar o orden posterior recorrido Pre seremos [R, la lista de elementos a menos de R, la lista de elementos mayores, entonces R] post será [lista de elementos a menos de R, la lista de elementos mayor que R, R]

pseudo código se verá así.

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