Gezet in een matrix de diepste pad van een BST (recursieve)

Probeer het gebruik van knooppunten als een instrument om de diepste pad te reconstrueren

Het probleem dat u zou kunnen hebben is dat je geen manier om de werkelijke nodes opslaan als u de boom doorkruisen. Wat je nodig hebt is een manier om "onthouden" welke knooppunten die u heeft bezocht op weg naar het blad dat u achten om de diepste zijn.

Als uw BST is vertegenwoordigd in knooppunten, wilt u misschien overwegen het opslaan van een verwijzing in elk kind, aan haar moedermaatschappij. Op die manier wanneer je moet de diepste blad, kunt u recursief reconstrueren de weg terug naar de root (NB: Het pad zal in omgekeerde volgorde). Als volgt:

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

Er zijn andere manieren om dit te doen als je niet wilt nodes te gebruiken, maar dit is een gemakkelijke manier om het probleem te visualiseren in je hoofd.

Met ouder referenties

Als u het opzetten van elk knooppunt zodat het een verwijzing naar haar moedermaatschappij, kun je gewoon op zoek naar de diepste knooppunt en dan terug lopen vanaf daar naar de wortel van de boom door het traceren via de ouders. Dat is zeker het makkelijkste om te doen ten koste van het hebben van een extra parentNodeverwijzing variabele in elk knooppunt.

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

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

Zonder ouder referenties

Als u niet ouder referenties hebben, dan kunt u bijhouden van de weg te houden van de wortel van de boom naar de "huidige" Node als je recurse door de boom. Elke keer dat je bottom-out, behalve dat pad als de "langste pad tot nu toe" als het pad langer is dan uw vorige "langste pad tot nu toe". Effectief betekent dit dat het maken van uw call stack expliciet.

Hier zijn een paar Python-achtig code:

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