Tedd be egy tömb a legmélyebb utat egy BST (rekurzív)

Próbáljon ki csomópontok, mint egy eszköz, hogy rekonstruálják a legmélyebb útvonal

A probléma lehet, mivel az, hogy nincs módja annak, hogy tárolja az aktuális csomópont ahogy áthalad a fát. Amire szüksége van egy módja annak, hogy „emlékszik”, amely a csomópontok a felkeresett az utat a levél, amit tartják, hogy a legmélyebb.

Ha a BST képviselteti magát a csomópontokon, akkor érdemes megfontolni, tárolására hivatkozni, minden gyermek, hogy a szülő. Így, ha van, hogy a legmélyebb levél, akkor rekurzívan rekonstruálni az utat vissza a gyökér (Megjegyzés: Az útvonal lesz fordított sorrendben). Így:

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

Vannak más módon kell ezt csinálni, ha nem kívánja használni csomópont, de ez egy egyszerű módja, hogy szemléltesse a probléma a fejedben.

A szülő referenciák

Ha beállította minden csomópont úgy, hogy van egy hivatkozás a szülő, akkor csak meg a legmélyebb csomópontot, majd séta vissza onnan a gyökér a fa tracing a szülők. Ez nem feltétlenül a legegyszerűbb dolog rovására egy extra parentNodereferencia változó minden csomóponton.

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

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

Anélkül szülő referenciák

Ha nincs szülő referenciák, akkor nyomon követheti az utat a gyökér a fa az „aktuális” node ahogy recurse át a fát. Minden alkalommal, amikor a mélypontot, kivéve, hogy az utat, mint a „leghosszabb út eddig”, ha az út hosszabb, mint az előző „leghosszabb út eddig.” Hatékonyan, hogy azt jelenti, hogy a hívás verem explicit.

Itt van néhány Python-szerű 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)