Lowest Common Ancestor of a Binary Search Tree

Author: dksifoua

README.md

@@ -47,6 +47,7 @@
 | 0219 | Easy       | Contains Duplicate II                          | Array                                                                       | [solution](./docs/0219-Contains-Duplicate-II.md)                          |
 | 0226 | Easy       | Invert Binary Tree                             | Tree, Depth-First Search, Breadth-First Search, Binary Tree                 | [solution](./docs/0226-Invert-Binary-Tree.md)                             |
 | 0230 | Medium     | Kth Smallest Element in a BST                  | Tree, Depth-First Search, Binary Search Tree, Binary Tree                   | [solution](./docs/0230-Kth-Smallest-Element-in-a-BST.md)                  |
+| 0236 | Medium     | Lowest Common Ancestor of a Binary Tree        | Tree, Depth-First Search, Binary Tree                                       | [solution](docs/0236-Lowest-Common-Ancestor-of-a-Binary-Tree.md)          |
 | 0238 | Medium     | Product of Array Except Self                   | Array                                                                       | [solution](./docs/0238-Product-Of-Array-Except-Self.md)                   |
 | 0239 | Hard       | Sliding Window Maximum                         | Array, Queue, Sliding Window, Heap (Priority Queue), Monotonic Queue        | [solution](./docs/0239-Sliding-Window-Maximum.md)                         |
 | 0242 | Easy       | Valid Anagram                                  | String, HashTable                                                           | [solution](./docs/0242-Valid-Anagram.md)                                  |   

docs/0236-Lowest-Common-Ancestor-of-a-Binary-Tree.md

@@ -0,0 +1,63 @@
+# 🧠 [Lowest Common Ancestor of a Binary Search Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/description/)
+
+## 📘 Problem Statement
+
+Given a **binary search tree (BST)**, find the **lowest common ancestor (LCA)** of two given nodes `p` and `q` 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).”
+
+---
+
+## 💡 Intuition
+
+In a **Binary Search Tree (BST)**:
+
+- All nodes in the left subtree of a node have smaller values.
+- All nodes in the right subtree have larger values.
+
+This structure allows a comparison-based traversal from the root to the correct ancestor.  
+The first node encountered where the path to `p` and `q` **splits** is the **lowest common ancestor**.
+
+---
+
+## 🔍 Approach
+
+The algorithm leverages the ordered nature of a BST:
+
+1. Start at the root node.
+2. At each step:
+    - If both `p` and `q` are less than the current node, LCA lies in the **left subtree**.
+    - If both `p` and `q` are greater than the current node, LCA lies in the **right subtree**.
+    - Otherwise, the current node is the **lowest common ancestor**.
+3. Stop the traversal once this condition is met.
+
+Edge cases:
+
+- If any of `p`, `q`, or `root` is `null`, it throws an `IllegalArgumentException`.
+- If either `p` or `q` is `null`, the other node is returned, following the descendant-of-itself rule.
+
+---
+
+## ⏱️ Complexity
+
+| Metric | Complexity                                               |
+|--------|----------------------------------------------------------|
+| Time   | `O(h)`, where *h* is the height of the BST                 |
+| Space  | `O(1)`, iterative traversal with no additional memory used |
+
+---
+
+## 🧪 Code
+
+- [Java](../src/main/java/io/dksifoua/leetcode/lowestcommonancestorofabinarysearchtree/Solution.java)
+
+---
+
+## ✅ Summary
+
+This solution takes advantage of the binary search tree's sorted properties to efficiently locate the lowest common
+ancestor without needing to traverse the entire tree. By narrowing the search space based on comparisons, it ensures an
+optimal `O(h)` runtime. This approach is simple, elegant, and scalable for large trees.

src/main/java/io/dksifoua/leetcode/lowestcommonancestorofabinarysearchtree/Solution.java

@@ -0,0 +1,34 @@
+package io.dksifoua.leetcode.lowestcommonancestorofabinarysearchtree;
+
+import io.dksifoua.leetcode.utils.TreeNode;
+
+public class Solution {
+
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        if (root == null || (p == null && q == null)) throw new IllegalArgumentException();
+        if (p == null) return q;
+        if (q == null) return p;
+
+        TreeNode current = root;
+        while (current != null) {
+            if ((p.getValue() < current.getValue() && current.getValue() < q.getValue())
+                    || (q.getValue() < current.getValue() && current.getValue() < p.getValue())) {
+                return current;
+            }
+
+            if (p.getValue() < current.getValue() && q.getValue() < current.getValue()) {
+                current = current.getLeft();
+                continue;
+            }
+
+            if (p.getValue() > current.getValue() && q.getValue() > current.getValue()) {
+                current = current.getRight();
+                continue;
+            }
+
+            break;
+        }
+
+        return current;
+    }
+}

src/test/java/io/dksifoua/leetcode/lowestcommonancestorofabinarysearchtree/SolutionTest.java

@@ -0,0 +1,81 @@
+package io.dksifoua.leetcode.lowestcommonancestorofabinarysearchtree;
+
+import io.dksifoua.leetcode.utils.TreeNode;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class SolutionTest {
+
+    private final Solution solution = new Solution();
+
+    @Test
+    void testLowestCommonAncestor_basicCase() {
+        TreeNode root = TreeNode.build(new Integer[] { 6, 2, 8, 0, 4, 7, 9, null, null, 3, 5 });
+        TreeNode p = findNode(root, 2);
+        TreeNode q = findNode(root, 8);
+        TreeNode expected = findNode(root, 6);
+
+        TreeNode result = solution.lowestCommonAncestor(root, p, q);
+
+        assertEquals(expected.getValue(), result.getValue());
+    }
+
+    @Test
+    void testLowestCommonAncestor_deepLeftSubtree() {
+        TreeNode root = TreeNode.build(new Integer[] { 6, 2, 8, 0, 4, 7, 9, null, null, 3, 5 });
+        TreeNode p = findNode(root, 2);
+        TreeNode q = findNode(root, 4);
+        TreeNode expected = findNode(root, 2);
+
+        TreeNode result = solution.lowestCommonAncestor(root, p, q);
+
+        assertEquals(expected.getValue(), result.getValue());
+    }
+
+    @Test
+    void testLowestCommonAncestor_sameNode() {
+        TreeNode root = TreeNode.build(new Integer[] { 6, 2, 8, 0, 4, 7, 9 });
+        TreeNode p = findNode(root, 2);
+        TreeNode result = solution.lowestCommonAncestor(root, p, p);
+
+        assertEquals(p.getValue(), result.getValue());
+    }
+
+    @Test
+    void testLowestCommonAncestor_pIsNull() {
+        TreeNode root = TreeNode.build(new Integer[] { 6, 2, 8 });
+        TreeNode q = findNode(root, 2);
+
+        assertEquals(q.getValue(), solution.lowestCommonAncestor(root, null, q).getValue());
+    }
+
+    @Test
+    void testLowestCommonAncestor_qIsNull() {
+        TreeNode root = TreeNode.build(new Integer[] { 6, 2, 8 });
+        TreeNode p = findNode(root, 8);
+
+        assertEquals(p.getValue(), solution.lowestCommonAncestor(root, p, null).getValue());
+    }
+
+    @Test
+    void testLowestCommonAncestor_rootIsNull() {
+        TreeNode p = new TreeNode(1, null, null);
+        TreeNode q = new TreeNode(2, null, null);
+
+        assertThrows(IllegalArgumentException.class, () -> solution.lowestCommonAncestor(null, p, q));
+    }
+
+    @Test
+    void testLowestCommonAncestor_bothPQNull() {
+        TreeNode root = new TreeNode(5, null, null);
+        assertThrows(IllegalArgumentException.class, () -> solution.lowestCommonAncestor(root, null, null));
+    }
+
+    private TreeNode findNode(TreeNode root, int value) {
+        if (root == null) return null;
+        if (root.getValue() == value) return root;
+        TreeNode left = findNode(root.getLeft(), value);
+        return (left != null) ? left : findNode(root.getRight(), value);
+    }
+}