Ponga en una matriz el camino más profundo de un BST (recursivo)

Intenta usar nodos como herramienta para reconstruir el camino más profundo

El problema que podría tener es que no tiene forma de almacenar los nodos reales mientras recorre el árbol. Lo que necesita es una forma de "recordar" qué nodos ha visitado en el camino hacia la hoja que considera más profundo.

Si su BST está representada en nodos, le recomendamos que almacene una referencia, en cada niño, en su padre. De esa manera, cuando llegue a la hoja más profunda, podría reconstruir recursivamente la ruta de regreso a la raíz (NOTA: la ruta será en orden inverso). Al igual que:

if (isDeepest(node)) { // Once you find the deepest node...
  return reconstructPath(node); // ...reconstruct the path that took you there.
}

...

// reconstructPath is a method that takes a node (the deepest leaf) as 
// an argument and returns an array of the nodes from that node to the root.
private Array reconstructPath(Node node) {
  Array deepestPath = new Array();
  while(node.parent != node) { // Go up until you reach the root, which will be itself.
    deepestPath.add(node); // Add the node to end of the Array
    node = node.parent; // Go up one level to the parent of the node
  }
  deepestPath.reverse(); // reverse the order so it goes root->leaf
  return deepestPath;
}

Hay otras maneras de hacerlo si no desea usar nodos, pero esta es una manera fácil de visualizar el problema en su cabeza.

Con referencias de padres

Si configura cada nodo para que tenga una referencia a su elemento primario, puede encontrar el nodo más profundo y luego retroceder desde allí a la raíz del árbol rastreando a través de los padres. Eso definitivamente es lo más fácil de hacer a expensas de tener una parentNodevariable de referencia adicional en cada nodo.

# Iterate through parents to trace the path in reverse.
node = deepestNode(tree)

while node.parent != None:
    node = node.parent

Sin referencias de padres

Si no tiene referencias parentales, puede hacer un seguimiento de la ruta desde la raíz del árbol hasta el nodo "actual" a medida que recurre a través del árbol. Siempre que toques fondo, guarda esa ruta como la "ruta más larga hasta el momento" si la ruta es más larga que tu "ruta más larga hasta el momento". Efectivamente eso significa hacer explícita su pila de llamadas.

Aquí hay un código Python-ish:

# Public function. Sets up globals and then calls helper.
def deepestPath(tree):
    global longestPath, currentPath

    # Reset for a new search.
    longestPath = []
    currentPath = []

    _deepestPath(tree.root)

    return longestPath

# Helper function that does the real work.    
def _deepestPath(node):
    global longestPath, currentPath

    currentPath.append(node)

    # No children, we've bottomed out.
    if not node.left and not node.right:
        if currentPath.length > longestPath.length:
            # Save a copy of the current path.
            longestPath = list(currentPath)

    # Recurse into children.
    else:
        if node.left:  _deepestPath(node.left)
        if node.right: _deepestPath(node.right)

    currentPath.pop(node)