Legen in ein Array die tiefste Pfad eines BST (rekursiv)

Versuchen Sie es mit Knoten als Werkzeug den tiefsten Weg zu rekonstruieren

Das Problem, das Sie könnte ist, dass Sie keine Möglichkeit haben, die tatsächlichen Knoten zu speichern, wie Sie den Baum durchlaufen. Was Sie brauchen, ist eine Möglichkeit, zu „erinnern“, die Knoten, die Sie auf dem Weg zu dem Blatt besucht haben, die Sie halten die tiefste zu sein.

Wenn Ihr BST in Knoten dargestellt wird, können Sie speichern eine Referenz zu betrachten, in jedem Kind, seine Eltern. Auf diese Weise, wenn Sie zum tiefstenen Blatt bekommen, kann man rekursiv den Weg zurück in die Wurzel (Hinweis: der Pfad in umgekehrter Reihenfolge sein wird) rekonstruieren. Wie so:

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

Es gibt auch andere Möglichkeiten, Knoten verwenden, tun wollen dies, wenn Sie nicht, aber das ist eine einfache Möglichkeit, das Problem in Ihrem Kopf zu visualisieren.

Mit Mutter Referenzen

Wenn Sie jeden Knoten so einrichten , dass es einen Verweis auf seine Eltern hat, können Sie nur den tiefsten Knoten finden und dann zu Fuß wieder nach oben von dort an die Wurzel des Baumes , indem sie durch die Eltern zu verfolgen. Das ist definitiv die einfachste Sache auf Kosten zu tun , eine extra zu haben parentNodein jedem Knoten Referenzgröße.

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

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

Ohne Mutter Referenzen

Wenn Sie keine übergeordneten Referenzen haben, dann können Sie den Überblick über den Pfad von der Wurzel des Baumes auf den „aktuellen“ Knoten halten, wie Sie durch den Baum Rekursion. Jedes Mal, wenn Sie unten aus, speichern diesen Weg als der „längste Weg so weit“, wenn der Pfad länger ist als Ihr bisheriger „längster Weg so weit“. Effektiv bedeutet, dass Ihr Call-Stack explizit zu machen.

Hier einige Python-ish 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)