Add lowest common ancestor LC medium Python

Author: nwthomas

src/leetcode/medium/lowest-common-ancestor/lowest_common_ancestor.py

@@ -0,0 +1,56 @@
+"""
+https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/description
+
+Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST.
+
+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 = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
+Output: 6
+Explanation: The LCA of nodes 2 and 8 is 6.
+
+Example 2:
+Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
+Output: 2
+Explanation: The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition.
+
+Example 3:
+Input: root = [2,1], p = 2, q = 1
+Output: 2
+ 
+Constraints:
+The number of nodes in the tree is in the range [2, 105].
+-109 <= Node.val <= 109
+All Node.val are unique.
+p != q
+p and q will exist in the BST.
+"""
+
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+def lowestCommonAncestor(root: TreeNode, p: TreeNode, q: TreeNode) -> TreeNode:
+    commonAncestor = None
+
+    def bfs(node) -> bool:
+        nonlocal commonAncestor
+
+        if node is None:
+            return False
+
+        left = bfs(node.left)
+        right = bfs(node.right)
+        isCurrentNode = node.val == p.val or node.val == q.val
+
+        if (left and right) or (left and isCurrentNode) or (right and isCurrentNode):
+            commonAncestor = node
+        
+        return left or right or isCurrentNode
+
+    bfs(root)
+
+    return commonAncestor

src/leetcode/medium/lowest-common-ancestor/test_lowest_common_ancestor.py

@@ -0,0 +1,37 @@
+from lowest_common_ancestor import lowestCommonAncestor, TreeNode
+import unittest
+
+class TestLowestCommonAncestor(unittest.TestCase):
+    def test_returns_lowest_common_ancestor(self):
+        """Takes in a tree and two nodes and returns the lowest common ancestor"""
+        root = TreeNode(6)
+        root.left = TreeNode(2)
+        root.right = TreeNode(8)
+        root.left.left = TreeNode(0)
+        root.left.right = TreeNode(4)
+        root.right.left = TreeNode(7)
+        root.right.right = TreeNode(9)
+        root.left.right.left = TreeNode(3)
+        root.left.right.right = TreeNode(5)
+
+        p = root.left
+        q = root.right
+
+        result = lowestCommonAncestor(root, p, q)
+        self.assertEqual(result, root)
+
+    def test_returns_lowest_common_ancestor_when_one_node_is_ancestor(self):
+        """Takes in a tree and two nodes where one is the ancestor and returns the ancestor"""
+        root = TreeNode(6)
+        root.left = TreeNode(2)
+        root.right = TreeNode(8)
+        root.left.left = TreeNode(0)
+
+        p = root.left
+        q = root.left.left
+
+        result = lowestCommonAncestor(root, p, q)
+        self.assertEqual(result, root.left)
+
+if __name__ == "__main__":
+    unittest.main()

src/leetcode/medium/medium.md

@@ -44,6 +44,7 @@
 -   [Longest Palindrome Subsequence](longest-palindrome-subsequence)
 -   [Longest Palindromic Substring](longest-palindrome-substring)
 -   [Longest Repeating Character Replacement](longest-repeating-character-replacement)
+-   [Lowest Common Ancestors](lowest-common-ancestor)
 -   [Longest Substring Without Repeating Characters](longest-substring-without-repeating-characters)
 -   [LRU Cache](lru-cache)
 -   [Lowest Common Ancestor of Binary Search Tree](lowest-common-ancestor-of-bst)