Umieszczono w tablicy najgłębsze ścieżkę BST (rekurencyjny)

Spróbuj użyć węzły jako narzędzie do rekonstrukcji najgłębszy ścieżkę

Problem może być o to, że nie masz sposób przechowywania rzeczywistych węzłów, jak przechodzić przez drzewo. Co trzeba to sposób na „pamiętać”, który odwiedzonych węzłów na drodze do liści, które uznają za najgłębszy.

Jeśli BST jest reprezentowana w węzłach, może warto rozważyć przechowywania odwołanie, w każdego dziecka, do jego rodzica. W ten sposób, gdy masz do najgłębszej liści, można rekurencyjnie rekonstruować drogę z powrotem do korzeni (uwaga: ścieżka będzie w odwrotnej kolejności). 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;
}

Istnieją inne sposoby, aby to zrobić, jeśli nie chcesz korzystać z węzłów, ale to jest łatwym sposobem na wizualizację problemu w głowie.

Z odniesieniami macierzystych

Jeśli każdy węzeł skonfigurować tak, że ma odniesienie do jego rodzica, można po prostu znaleźć najgłębszy węzeł, a następnie pieszo z powrotem stamtąd do korzenia drzewa poprzez śledzenie przez rodziców. To jest zdecydowanie najłatwiej zrobić kosztem posiadające dodatkową parentNodezmienną referencyjną w każdym węźle.

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

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

Bez odniesień macierzystych

Jeśli nie masz referencji macierzyste, można śledzić ścieżkę z korzenia drzewa do „bieżącego” węzła jak przeszukanie przez drzewa. Za każdym razem kiedy się na dole, zapisać tę ścieżkę jako „najdłuższej ścieżce tak daleko”, jeśli ścieżka jest dłuższa niż poprzedni „najdłuższej ścieżce tak daleko”. Skutecznie to znaczy podejmowaniu stos wywołań jednoznaczne.

Oto niektóre kodu Python-owski:

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