Mettere in un array percorso più profondo di un BST (ricorsiva)

Provare a usare nodi come strumento per ricostruire il percorso più profondo

Il problema si potrebbe avere è che non c'è modo per memorizzare i nodi effettivi mentre attraversate l'albero. Quello che vi serve è un modo per "ricordare" quali nodi hai visitato sulla strada per la foglia che si ritengono essere la più profonda.

Se il BST è rappresentato in nodi, si potrebbe prendere in considerazione la memorizzazione di un riferimento, in ogni bambino, al suo genitore. In questo modo quando si ha alla foglia più profondo, si potrebbe ricorsivamente ricostruire il percorso di ritorno alla radice (Nota: il percorso sarà in ordine inverso). Così:

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

Ci sono altri modi per fare questo se non si desidera utilizzare i nodi, ma questo è un modo semplice per visualizzare il problema nella tua testa.

Con riferimenti genitore

Se si configurare ogni nodo in modo che abbia un riferimento al suo genitore, si può solo trovare il nodo più profonda e poi tornare a piedi da lì alla radice dell'albero tracciando attraverso i genitori. Questa è sicuramente la cosa più semplice da fare, a scapito di avere un extra parentNodevariabile di riferimento in ciascun nodo.

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

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

Senza riferimenti genitore

Se non si dispone di riferimenti genitore, quindi è possibile tenere traccia del percorso dalla radice dell'albero al nodo "corrente", come si ricorsione attraverso l'albero. Ogni volta che il fondo, salvo che il percorso come il "percorso più lungo finora" se il percorso è più lungo di una precedente "percorso più lungo finora". Effettivamente questo significa rendere il vostro stack di chiamata esplicita.

Ecco alcuni codice 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)