Pune într-o matrice cea mai profundă calea unui BST (recursiv)

Încercați să folosiți noduri ca un instrument pentru a reconstrui cel mai adânc calea

Problema ar putea fi având este că nu aveți nici o modalitate de a stoca nodurile reale pe măsură ce traversa copac. Ceea ce ai nevoie este o modalitate de a „aminti“, pe care le-ați vizitat nodurile pe drumul spre frunza pe care le consideră a fi cele mai profunde.

Dacă BST este reprezentată în noduri, s-ar putea dori să ia în considerare stocarea o referință, în fiecare copil, la părintele său. În acest fel, atunci când a ajuns la cea mai adâncă frunze, ai putea reconstrui recursiv drumul înapoi la rădăcina (NOTĂ: Calea va fi în ordine inversă). Ca astfel:

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

Există și alte modalități de a face acest lucru, dacă nu doriți să utilizați noduri, dar acest lucru este o modalitate ușoară de a vizualiza problema în cap.

Cu referințe părinte

Dacă configurați fiecare nod , astfel încât acesta are o trimitere la părintele său, puteți găsi doar cel mai adânc nod și apoi de mers înapoi de acolo la rădăcina copacului prin trasarea prin părinți. Aceasta este cu siguranță cel mai ușor lucru de făcut în detrimentul de a avea un plus de parentNodevariabilă de referință în fiecare nod.

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

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

Fără referințe părinte

Dacă nu aveți referințe părinte, atunci puteți urmări calea de la rădăcina arborelui la nodul „curent“, în timp ce recurse prin copac. De fiecare dată când fund, salvați această cale ca fiind „cea mai lungă calea de până acum“, în cazul în care calea este mai lung decât precedenta dvs. „cea mai lungă cale până acum“. Efectiv, care înseamnă a face stiva apel explicit.

Iată un exemplu de cod Python-ish:

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