Mettre dans un réseau le plus profond d'un chemin BST (récursif)

Essayez d'utiliser des nœuds comme un outil pour reconstituer le plus profond chemin

Le problème que vous pourriez avoir est que vous avez aucun moyen de stocker les nœuds réels que vous traversez l'arbre. Qu'est-ce que vous avez besoin est un moyen de « se souvenir » nœuds que vous avez visités sur le chemin de la feuille que vous jugez être le plus profond.

Si votre BST est représenté dans les noeuds, vous voudrez peut-être envisager de stocker une référence, dans chaque enfant, à son parent. De cette façon, lorsque vous avez à la feuille la plus profonde, vous pouvez reconstruire récursive le chemin du retour à la racine (REMARQUE: Le chemin sera dans l'ordre inverse). Ainsi:

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

Il existe d'autres façons de le faire si vous ne voulez pas utiliser des nœuds, mais cela est un moyen facile de visualiser le problème dans votre tête.

Avec des références mères

Si vous configurez chaque nœud afin qu'il ait une référence à son parent, vous pouvez juste trouver le plus profond nœud et ensuite revenir de là à la racine de l'arbre en traçant à travers les parents. C'est sans aucun doute la chose la plus facile à faire au détriment d'avoir un supplément parentNodevariable de référence dans chaque noeud.

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

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

Sans références mères

Si vous ne disposez pas de références mères, vous pouvez garder une trace du chemin depuis la racine de l'arbre au nœud « courant » que vous RECURSE à travers l'arbre. Chaque fois que vous toucher le fond, sauf ce chemin comme « le plus long chemin jusqu'à présent » si le chemin est plus long que votre précédent « plus long chemin jusqu'à présent ». En effet cela signifie rendre votre pile d'appel explicite.

Voici un code 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)