Satt inn i en matrise den dypeste løpet av en BST (rekursiv)

Prøv å bruke noder som et verktøy for å rekonstruere den dypeste løpet

Problemet du kanskje har er at du har ingen måte å lagre selve noder som du traversere treet. Det du trenger er en måte å "huske" hvilke noder du har besøkt på vei til bladet at du anser for å være den dypeste.

Hvis BST er representert i noder, vil du kanskje vurdere å lagre en referanse, i hvert barn, til sin overordnede. På den måten når du fikk til den dypeste blad, kan du rekursivt rekonstruere veien tilbake til roten (MERK: Banen vil være i omvendt rekkefølge). Som så:

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

Det finnes andre måter å gjøre dette hvis du ikke ønsker å bruke noder, men dette er en enkel måte å visualisere problemet i hodet ditt.

Med foreldre referanser

Hvis du setter opp hver node, slik at den har en referanse til sin overordnede, kan du bare finne den dypeste node og deretter gå tilbake opp derfra til roten av treet ved å spore gjennom foreldrene. Det er definitivt den enkleste ting å gjøre på bekostning av å ha en ekstra parentNodereferanse variabel i hver node.

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

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

Uten foreldre referanser

Hvis du ikke har foreldre referanser, så kan du holde oversikt over banen fra roten av treet til "dagens" node som du recurse gjennom treet. Hver gang du bunnen ut, lagre den veien som "lengste banen så langt" hvis banen er lengre enn den forrige "lengste banen så langt". Effektivt som betyr å gjøre samtalen stabelen eksplisitt.

Her er noen Python-ish kode:

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