# Python Approaches to Find the Lowest Common Ancestor in a Binary Tree Using Parent Pointers

π‘ Problem Formulation: In binary trees, the Lowest Common Ancestor (LCA) of two nodes v and w is the lowest (i.e., deepest) node that has both v and w as descendants. A particular challenge arises when each node has a pointer to its parent. Our task is to identify the LCA with this additional data structure, given nodes v and w. We aim for efficiency and a clean, understandable solution. For example, given nodes v and w in a tree structure, we want our program to return the node that is their lowest common ancestor.

## Method 1: Using a HashSet to Track Ancestors

This first method involves tracking the ancestors of one node using a HashSet, then traversing the tree upwards from the second node until we encounter a node already in the HashSet. The first common node is the LCA. The function specification would simply require two nodes as arguments and return their LCA.

Here’s an example:

```class Node:
def __init__(self, key, parent=None):
self.key = key
self.parent = parent

def find_LCA(node1, node2):
ancestors = set()
while node1:
node1 = node1.parent
while node2 and node2 not in ancestors:
node2 = node2.parent
return node2

# Assume we have a binary tree and nodes n1 and n2
n1 = Node(1)
n2 = Node(2, n1)  # n2's parent is n1
lca = find_LCA(n2, n1)
print(f"The LCA of n1 and n2 is: {lca.key}")```

The output of this code snippet:

`The LCA of n1 and n2 is: 1`

This code snippet defines a simple class `Node` with a key and a parent. The function `find_LCA` creates an ancestor set and iterates through the parents of the first and second node until it finds the common ancestor. It is a straightforward way to find the LCA with a time complexity of O(h), where h is the height of the tree.

## Method 2: Traversing Up Using Two Pointers

This method avoids using extra space by employing a two-pointer technique. The idea is to first find the depths of both nodes, and then align them at the same depth by moving up the deeper node. After aligning, traverse up until the nodes meet, which would be the LCA.

Here’s an example:

```def find_depth(node):
depth = 0
while node:
node = node.parent
depth += 1
return depth

def find_LCA(node1, node2):
depth1, depth2 = find_depth(node1), find_depth(node2)
# Align the depths
while depth1 > depth2:
node1 = node1.parent
depth1 -= 1
while depth2 > depth1:
node2 = node2.parent
depth2 -= 1
# Find the LCA
while node1 != node2:
node1 = node1.parent
node2 = node2.parent
return node1

# Below the code would be similar to define the tree and calculate LCA.```

The output and use of this code would be similar to method 1, showing the LCA’s key when run.

This method computes the depth of each node and then traverses the tree upwards, keeping the traversal of both nodes in sync until the LCA is found. This method also runs in O(h) time but does not require any extra space unlike the first method.

## Method 3: Optimizing the Traversal Up with Recursion

In this method, we optimize the traversal upwards by utilizing recursion. The logic is similar to method 2 in finding the depth of each node and aligning them at the same level. Then, we recursively move up the tree until we find the LCA. It’s a neat and elegant recursive solution that makes the code look cleaner.

Here’s an example:

```def find_LCA_recursive(node1, node2, depth1, depth2):
if depth1 > depth2:
return find_LCA_recursive(node1.parent, node2, depth1-1, depth2)
elif depth2 > depth1:
return find_LCA_recursive(node1, node2.parent, depth1, depth2-1)
else:
if node1 == node2:
return node1
return find_LCA_recursive(node1.parent, node2.parent, depth1-1, depth2-1)

# The rest of the code remains the same for computing depths and calling the recursive function.```

The output and explanation are similar to the previous methods, leading to the display of the LCA.

This recursive approach ensures that each call is made at a higher level in the tree until the nodes converge. The time complexity remains O(h). However, this method may cause a stack overflow if the tree is very deep, due to the recursive nature of the implementation.

## Method 4: Path Comparison

With path comparison, you store the paths to the node1 and node2 from the root and then iterate over both paths until they diverge. The last common node before divergence is the LCA. Although the nodes contain parent pointers and no explicit root, we consider the root here as the farthest node from the given nodes.

Here’s an example:

```def find_paths(node):
path = []
while node:
path.append(node)
node = node.parent
return path[::-1]

def find_LCA_by_paths(node1, node2):
path1, path2 = find_paths(node1), find_paths(node2)
lca = None
for u, v in zip(path1, path2):
if u == v:
lca = u
else:
break
return lca

# Tree definition and LCA computation follows the same structure as previous examples.```

The output of this code would be similar to the other methods, showing the LCA’s key.

This method reverses the path to the root for both nodes, then compares them side by side until the paths diverge. It has a space complexity of O(h), where h is the height of the tree, and could be inefficient if the tree is very deep.

## Bonus One-Liner Method 5: Using Generators

For a quick and elegant one-liner solution, we can use a Python generator expression inside the `next()` function. This combines methods 1 and 4 by using set intersection and path comparison compactly to find the LCA.

Here’s an example:

```find_LCA_one_liner = lambda node1, node2: next((n for n in find_paths(node1) if n in find_paths(node2)), None)

# Assuming find_paths is defined as in Method 4 and nodes are already defined, call the function as follows
# lca = find_LCA_one_liner(n1, n2)```

The output will display the LCA’s key just like the other methods.

This code snippet leverages the `next()` function to find the first common node in the paths to the root of node1 and node2. It executes a generator expression that stops at the first intersection, making it an efficient solution and one that is also very concise.

## Summary/Discussion

• Method 1: HashSet Ancestor Tracking. Easy to understand. Requires O(h) space. Inefficient if many nodes are to be queried.
• Method 2: Two Pointer Depth Alignment. Optimizes space. Only requires O(1) extra space. Time complexity is O(h).
• Method 3: Recursive Upward Traversal. Cleaner code with recursion. Risks stack overflow in deep trees. Time complexity remains O(h).
• Method 4: Path Comparison. Explicit and straightforward but can be memory-heavy if tree depth is significant, due to storing of paths.
• Bonus One-Liner Method 5: Generators with Intersection. Elegant and concise solution. Combines path comparison and set intersection efficiently.