Lowest coomon ancestor of a binary search tree

Author: volodimyr

235.lowest_common_ancestor_of_a_binary_search_tree/lca.go

@@ -0,0 +1,50 @@
+// 235. Lowest coomon ancestor of a binary search tree
+// Topics: 'Depth-First Search', 'Tree', 'Binary Search Tree', 'Binary Tree'
+// Level: 'Medium'
+
+// 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.
+
+package lowestcommonancestorofabinarysearchtree
+
+func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
+	if p.Val < root.Val && q.Val < root.Val {
+		return lowestCommonAncestor(root.Left, p, q)
+	}
+	if p.Val > root.Val && q.Val > root.Val {
+		return lowestCommonAncestor(root.Right, p, q)
+	}
+	return root
+}
+
+type TreeNode struct {
+	Right *TreeNode
+	Left  *TreeNode
+	Val   int
+}

235.lowest_common_ancestor_of_a_binary_search_tree/lca_test.go

@@ -0,0 +1,213 @@
+package lowestcommonancestorofabinarysearchtree
+
+import "testing"
+
+func TestLowestCommonAncestor(t *testing.T) {
+	tests := []struct {
+		name     string
+		root     *TreeNode
+		p        *TreeNode
+		q        *TreeNode
+		expected int
+	}{
+		{
+			name: "Example 1: LCA of 2 and 8 is 6",
+			//       6
+			//      / \
+			//     2   8
+			//    / \ / \
+			//   0  4 7  9
+			//     / \
+			//    3   5
+			root: &TreeNode{
+				Val: 6,
+				Left: &TreeNode{
+					Val: 2,
+					Left: &TreeNode{
+						Val: 0,
+					},
+					Right: &TreeNode{
+						Val: 4,
+						Left: &TreeNode{
+							Val: 3,
+						},
+						Right: &TreeNode{
+							Val: 5,
+						},
+					},
+				},
+				Right: &TreeNode{
+					Val: 8,
+					Left: &TreeNode{
+						Val: 7,
+					},
+					Right: &TreeNode{
+						Val: 9,
+					},
+				},
+			},
+			p:        &TreeNode{Val: 2},
+			q:        &TreeNode{Val: 8},
+			expected: 6,
+		},
+		{
+			name: "Example 2: LCA of 2 and 4 is 2",
+			//       6
+			//      / \
+			//     2   8
+			//    / \ / \
+			//   0  4 7  9
+			//     / \
+			//    3   5
+			root: &TreeNode{
+				Val: 6,
+				Left: &TreeNode{
+					Val: 2,
+					Left: &TreeNode{
+						Val: 0,
+					},
+					Right: &TreeNode{
+						Val: 4,
+						Left: &TreeNode{
+							Val: 3,
+						},
+						Right: &TreeNode{
+							Val: 5,
+						},
+					},
+				},
+				Right: &TreeNode{
+					Val: 8,
+					Left: &TreeNode{
+						Val: 7,
+					},
+					Right: &TreeNode{
+						Val: 9,
+					},
+				},
+			},
+			p:        &TreeNode{Val: 2},
+			q:        &TreeNode{Val: 4},
+			expected: 2,
+		},
+		{
+			name: "Example 3: LCA of 2 and 1 is 2",
+			//   2
+			//  /
+			// 1
+			root: &TreeNode{
+				Val: 2,
+				Left: &TreeNode{
+					Val: 1,
+				},
+			},
+			p:        &TreeNode{Val: 2},
+			q:        &TreeNode{Val: 1},
+			expected: 2,
+		},
+		{
+			name: "LCA of 0 and 5 is 2",
+			//       6
+			//      / \
+			//     2   8
+			//    / \ / \
+			//   0  4 7  9
+			//     / \
+			//    3   5
+			root: &TreeNode{
+				Val: 6,
+				Left: &TreeNode{
+					Val: 2,
+					Left: &TreeNode{
+						Val: 0,
+					},
+					Right: &TreeNode{
+						Val: 4,
+						Left: &TreeNode{
+							Val: 3,
+						},
+						Right: &TreeNode{
+							Val: 5,
+						},
+					},
+				},
+				Right: &TreeNode{
+					Val: 8,
+					Left: &TreeNode{
+						Val: 7,
+					},
+					Right: &TreeNode{
+						Val: 9,
+					},
+				},
+			},
+			p:        &TreeNode{Val: 0},
+			q:        &TreeNode{Val: 5},
+			expected: 2,
+		},
+		{
+			name: "LCA of 7 and 9 is 8",
+			//       6
+			//      / \
+			//     2   8
+			//    / \ / \
+			//   0  4 7  9
+			//     / \
+			//    3   5
+			root: &TreeNode{
+				Val: 6,
+				Left: &TreeNode{
+					Val: 2,
+					Left: &TreeNode{
+						Val: 0,
+					},
+					Right: &TreeNode{
+						Val: 4,
+						Left: &TreeNode{
+							Val: 3,
+						},
+						Right: &TreeNode{
+							Val: 5,
+						},
+					},
+				},
+				Right: &TreeNode{
+					Val: 8,
+					Left: &TreeNode{
+						Val: 7,
+					},
+					Right: &TreeNode{
+						Val: 9,
+					},
+				},
+			},
+			p:        &TreeNode{Val: 7},
+			q:        &TreeNode{Val: 9},
+			expected: 8,
+		},
+		{
+			name: "Small tree with two nodes",
+			//  10
+			//  /
+			// 5
+			root: &TreeNode{
+				Val: 10,
+				Left: &TreeNode{
+					Val: 5,
+				},
+			},
+			p:        &TreeNode{Val: 10},
+			q:        &TreeNode{Val: 5},
+			expected: 10,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := lowestCommonAncestor(tt.root, tt.p, tt.q)
+			if result.Val != tt.expected {
+				t.Errorf("expected %d, got %d", tt.expected, result.Val)
+			}
+		})
+	}
+}