Do pole nejhlubší dráhu BST (rekurzivní)

Zkuste použít uzlů jako nástroje k rekonstrukci nejhlubší cestu

Problém možná budete mít, je, že budete mít žádný způsob, jak uložit aktuální uzly, jak si procházet strom. To, co potřebujete, je způsob, jak „pamatovat“, které uzly, které jste navštívili na cestě do listu, který považují za nejhlubší.

Je-li váš BST zastoupena v uzlech, možná budete chtít, aby zvážila uložení odkazu v každé dítě, jeho rodiče. Tímto způsobem, když se dostal do nejhlubšího listu, můžete rekurzivně rekonstruovat cestu zpět do kořenového adresáře (poznámka: Cesta bude v obráceném pořadí). Jako tak:

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

Existují i ​​jiné způsoby, jak dělat to, pokud nechcete používat uzly, ale je to snadný způsob, jak představit problém ve vaší hlavě.

S mateřskými referencí

Nastavíte-li si každý uzel tak, že obsahuje odkaz na své mateřské společnosti, můžete jen najít nejhlubší uzel a pak pěšky zpátky odtamtud ke kořeni stromu sledováním prostřednictvím rodičů. To je určitě nejjednodušší věc udělat, na úkor s další parentNodereferenční proměnné v každém uzlu.

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

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

Bez mateřských referencí

Pokud nemáte nadřazené odkazy, pak můžete sledovat cestu od kořene stromu „aktuální“ uzel, jak rekurzivně přes stromu. Kdykoliv spodní ven, kromě toho, že cesta za „nejdelší cestu tak daleko“, pokud je cesta delší než předchozí „nejdelší cestu tak daleko“. Efektivně to znamená, aby vaše zásobník volání explicitní.

Zde je několik Python-ish kód:

# 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)