LeetCode //C - 236. Lowest Common Ancestor of a Binary Tree

236. Lowest Common Ancestor of a Binary Tree

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.

According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes p and q as the lowest node in T that has both p and q as descendants (where we allow a node to be a descendant of itself).”
 

Example 1:

Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
Output: 3
Explanation: The LCA of nodes 5 and 1 is 3.

Example 2:

Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
Output: 5
Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition.

Example 3:

Input: root = [1,2], p = 1, q = 2
Output: 1

Constraints:

• The number of nodes in the tree is in the range [$2,10^5$].
• $-10^9<=Node.val<=10^9$
• All Node.val are unique.
• p != q
• p and q will exist in the tree.

From: LeetCode
Link: 236. Lowest Common Ancestor of a Binary Tree

---

Solution:

Ideas：

1. Start from the root of the tree.
2. If the current node is either p or q, then return the current node. This means that we’ve found one of the two nodes.
3. Recursively check the left and right child of the current node.
4. If both left and right child recursive calls return non-NULL values, this means both p and q are found in different subtrees. Thus, the current node is their LCA.
5. If only one of the left or right child recursive calls returns a non-NULL value, return that non-NULL value. This means one of the nodes is found in a subtree.

Code:

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
struct TreeNode* lowestCommonAncestor(struct TreeNode* root, struct TreeNode* p, struct TreeNode* q) {
    // Base case: if root is NULL or root is either p or q, return root
    if (!root || root == p || root == q) {
        return root;
    }
    
    // Recursively check left and right subtrees
    struct TreeNode* left = lowestCommonAncestor(root->left, p, q);
    struct TreeNode* right = lowestCommonAncestor(root->right, p, q);
    
    // If both left and right recursive calls return non-NULL, then root is the LCA
    if (left && right) {
        return root;
    }
    
    // Otherwise, return the non-NULL child
    return left ? left : right;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26