# 5 Best Ways to Find a Common Ancestor of Two Elements in a Binary Tree

π‘ Problem Formulation: Binary Trees are a fundamental structure in computer science, and finding a common ancestor to two nodes is a classic problem. Given a binary tree and two of its node values, the goal is to find the lowest common ancestor (LCA) – the deepest node that has both nodes as descendants (where we allow a node to be a descendant of itself). For example, in a binary tree where nodes have values 1 through 8, the LCA of nodes 4 and 5 would be 2.

## Method 1: Recursive Approach

This method utilizes recursion to traverse the binary tree in a depth-first manner. It compares the current node’s value to the given two node values. If the current node matches either of the node values, or if one node is found in the left subtree and the other in the right subtree, the current node is the LCA.

Here’s an example:

```class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None

def find_LCA(root, n1, n2):
if root is None:
return None
if root.val == n1 or root.val == n2:
return root
left_lca = find_LCA(root.left, n1, n2)
right_lca = find_LCA(root.right, n1, n2)
if left_lca and right_lca:
return root
return left_lca if left_lca else right_lca

# Construct the binary tree
root = TreeNode(3)
root.left = TreeNode(5)
root.right = TreeNode(1)
root.left.left = TreeNode(6)
root.left.right = TreeNode(2)
root.right.left = TreeNode(0)
root.right.right = TreeNode(8)

# Find LCA of nodes 6 and 2
lca = find_LCA(root, 6, 2)
print('LCA:', lca.val if lca else 'None')```

The output of this code snippet:

`LCA: 5`

This code defines a binary tree and a function `find_LCA()` to find the lowest common ancestor by checking for the presence of the two nodes in the subtrees and using the call stack to backtrack to the lowest common ancestor. It demonstrates recursion and binary tree traversal.

## Method 2: Iterative Using Parent Pointers

The iterative approach with parent pointers simplifies the process of finding ancestors by storing parent pointers at each node. By tracing each node up to the root and storing the path, one can find the intersection of the paths to determine the LCA.

Here’s an example:

```def find_LCA_with_parent(root, n1, n2):
parent = {root: None}
stack = [root]

# Iterate until we find both the nodes while also setting up parent pointers
while n1 not in parent or n2 not in parent:
node = stack.pop()
if node.left:
parent[node.left] = node
stack.append(node.left)
if node.right:
parent[node.right] = node
stack.append(node.right)

# Create a set of ancestors for n1
ancestors = set()
while n1:
n1 = parent[n1]

# The first ancestor of n2 which appears in n1's ancestor set is our LCA
while n2 not in ancestors:
n2 = parent[n2]

return n2

# Usage with example binary tree from Method 1
lca = find_LCA_with_parent(root, root.left.left, root.left.right)
print('LCA:', lca.val if lca else 'None')```

The output of this code snippet:

`LCA: 5`

This snippet involves creating a dictionary to keep track of parent pointers and iterating through the tree to fill this dictionary. It then uses two while loops to determine the common ancestor. This code showcases an iterative approach and avoid using recursion.

## Method 3: Path Comparison

This solution involves finding the paths from the root to the two given nodes and then comparing the paths to identify the last common node. This is the lowest common ancestor. The path comparison method is straightforward and intuitive as it mirrors actual tree path tracing.

Here’s an example:

```def find_path(root, path, k):
if root is None:
return False
path.append(root.val)
if root.val == k:
return True
if ((root.left and find_path(root.left, path, k)) or
(root.right and find_path(root.right, path, k))):
return True
path.pop()
return False

def find_LCA_by_path(root, n1, n2):
path1 = []
path2 = []

if not find_path(root, path1, n1) or not find_path(root, path2, n2):
return None

i = 0
while i < len(path1) and i < len(path2):
if path1[i] != path2[i]:
break
i += 1

return path1[i-1]

# Using example binary tree from Method 1
lca = find_LCA_by_path(root, 6, 2)
print('LCA:', lca)```

The output of this code snippet:

`LCA: 5`

This snippet defines methods to find paths from root to the given nodes and to find the LCA. The `find_LCA_by_path()` function uses these paths to determine the last common node before the paths diverge, providing the LCA without modifying the tree structure.

## Method 4: Depth-First Search with Memoization

The DFS method enhanced by memoization executes a tree traversal while storing the results of subproblems (whether a node is an ancestor of n1 or n2) to reuse in the computation of higher-level problems. Thus, efficiency is gained by not recalculating for each subtree.

Here’s an example:

```def find_LCA_DFS_memo(root, n1, n2, memo):
if root is None or root.val == n1 or root.val == n2:
return root
if (root, n1, n2) in memo:
return memo[(root, n1, n2)]

left = find_LCA_DFS_memo(root.left, n1, n2, memo)
right = find_LCA_DFS_memo(root.right, n1, n2, memo)

memo[(root, n1, n2)] = root if left and right else left or right
return memo[(root, n1, n2)]

# Usage with example binary tree from Method 1
lca = find_LCA_DFS_memo(root, 6, 2, {})
print('LCA:', lca.val if lca else 'None')```

The output of this code snippet:

`LCA: 5`

This code employs a memoization technique along with DFS to find the LCA. It checks if a subproblem has been solved and stores the answer to avoid unnecessary recalculations, improving the time complexity of the algorithm.

## Bonus One-Liner Method 5: Using Python’s Built-in Features

While not always the most efficient, Python’s expressive syntax allows for one-liner solutions that can be suitable for less complex trees or small-scale problems. Here’s a creative but less practical approach that uses modern Python features.

Here’s an example:

```find_LCA_one_liner = lambda root, n1, n2: root if (root.val in (n1, n2)) or ((find_LCA_one_liner(root.left, n1, n2)) and (find_LCA_one_liner(root.right, n1, n2))) else find_LCA_one_liner(root.left, n1, n2) or find_LCA_one_liner(root.right, n1, n2)

# Usage with example binary tree from Method 1
lca = find_LCA_one_liner(root, 6, 2)
print('LCA:', lca.val if lca else 'None')```

The output of this code snippet:

`LCA: 5`

This is an elegant one-liner lambda function that applies the recursive method to find the LCA. Note, this approach, while succinct, may not be the most readable or efficient due to its recursive nature and lack of memoization.

## Summary/Discussion

• Method 1: Recursive Approach. It’s a classic approach suitable for many problems; however, it can lead to a stack overflow for very deep trees or when tail recursion is not optimized by the interpreter.
• Method 2: Iterative Using Parent Pointers. Offers direct tracking of ancestors without recursion, but requires extra space for storing parent pointers.
• Method 3: Path Comparison. Simple and intuitive, mimicking manual tracing of paths, yet it incurs extra space for path storage and its time complexity can be higher in cases with deep and unbalanced trees.
• Method 4: Depth-First Search with Memoization. Saves computation time by caching intermediate results, it is effective for complex trees but might be overkill for smaller or simpler tree structures.
• Method 5: Using Python’s Built-in Features. Demonstrates the power of Python’s syntax but at the cost of readability and potential performance drawbacks.