Subtree of another tree

Author: volodimyr

572.subtree_of_another_tree/subtree.go

@@ -0,0 +1,54 @@
+//572. Subtree of another tree
+// Topics: 'Tree', 'Binary Tree', 'Depth-First Search', 'String Matching', 'Hash Function'
+
+// Given the roots of two binary trees root and subRoot, return true if there is a subtree of root with the same structure and node values of subRoot and false otherwise.
+
+// A subtree of a binary tree tree is a tree that consists of a node in tree and all of this node's descendants. The tree tree could also be considered as a subtree of itself.
+
+// Example 1:
+
+// Input: root = [3,4,5,1,2], subRoot = [4,1,2]
+// Output: true
+
+// Example 2:
+
+// Input: root = [3,4,5,1,2,null,null,null,null,0], subRoot = [4,1,2]
+// Output: false
+
+// Constraints:
+
+//     The number of nodes in the root tree is in the range [1, 2000].
+//     The number of nodes in the subRoot tree is in the range [1, 1000].
+//     -104 <= root.val <= 104
+//     -104 <= subRoot.val <= 104
+
+package subtreeofanothertree
+
+func isSubtree(root *TreeNode, subRoot *TreeNode) bool {
+	if root == nil {
+		return false
+	}
+	if root.Val == subRoot.Val && equal(root, subRoot) {
+		return true
+	}
+	return isSubtree(root.Left, subRoot) || isSubtree(root.Right, subRoot)
+}
+
+func equal(subRoot0, subRoot *TreeNode) bool {
+	if subRoot0 == nil && subRoot == nil {
+		return true
+	}
+	if subRoot0 == nil || subRoot == nil {
+		return false
+	}
+	if subRoot0.Val != subRoot.Val {
+		return false
+	}
+	return equal(subRoot0.Left, subRoot.Left) && equal(subRoot0.Right, subRoot.Right)
+}
+
+type TreeNode struct {
+	Val   int
+	Right *TreeNode
+	Left  *TreeNode
+}

572.subtree_of_another_tree/subtree_test.go

@@ -0,0 +1,220 @@
+package subtreeofanothertree
+
+import "testing"
+
+func TestIsSubtree(t *testing.T) {
+	tests := []struct {
+		name    string
+		root    *TreeNode
+		subRoot *TreeNode
+		want    bool
+	}{
+		{
+			name: "example 1 - subtree exists",
+			root: &TreeNode{
+				Val: 3,
+				Left: &TreeNode{
+					Val:   4,
+					Left:  &TreeNode{Val: 1},
+					Right: &TreeNode{Val: 2},
+				},
+				Right: &TreeNode{Val: 5},
+			},
+			subRoot: &TreeNode{
+				Val:   4,
+				Left:  &TreeNode{Val: 1},
+				Right: &TreeNode{Val: 2},
+			},
+			want: true,
+		},
+		{
+			name: "example 2 - subtree does not exist",
+			root: &TreeNode{
+				Val: 3,
+				Left: &TreeNode{
+					Val: 4,
+					Left: &TreeNode{
+						Val:  1,
+						Left: &TreeNode{Val: 0},
+					},
+					Right: &TreeNode{Val: 2},
+				},
+				Right: &TreeNode{Val: 5},
+			},
+			subRoot: &TreeNode{
+				Val:   4,
+				Left:  &TreeNode{Val: 1},
+				Right: &TreeNode{Val: 2},
+			},
+			want: false,
+		},
+		{
+			name: "root and subRoot are identical",
+			root: &TreeNode{
+				Val:   1,
+				Left:  &TreeNode{Val: 2},
+				Right: &TreeNode{Val: 3},
+			},
+			subRoot: &TreeNode{
+				Val:   1,
+				Left:  &TreeNode{Val: 2},
+				Right: &TreeNode{Val: 3},
+			},
+			want: true,
+		},
+		{
+			name:    "single node match",
+			root:    &TreeNode{Val: 1},
+			subRoot: &TreeNode{Val: 1},
+			want:    true,
+		},
+		{
+			name:    "single node no match",
+			root:    &TreeNode{Val: 1},
+			subRoot: &TreeNode{Val: 2},
+			want:    false,
+		},
+		{
+			name: "subRoot is a leaf in root",
+			root: &TreeNode{
+				Val: 1,
+				Left: &TreeNode{
+					Val:  2,
+					Left: &TreeNode{Val: 4},
+				},
+				Right: &TreeNode{Val: 3},
+			},
+			subRoot: &TreeNode{Val: 4},
+			want:    true,
+		},
+		{
+			name: "partial match - different structure",
+			root: &TreeNode{
+				Val: 1,
+				Left: &TreeNode{
+					Val:   2,
+					Right: &TreeNode{Val: 3},
+				},
+			},
+			subRoot: &TreeNode{
+				Val:  2,
+				Left: &TreeNode{Val: 3},
+			},
+			want: false,
+		},
+		{
+			name: "subRoot larger than any subtree",
+			root: &TreeNode{
+				Val:   1,
+				Left:  &TreeNode{Val: 2},
+				Right: &TreeNode{Val: 3},
+			},
+			subRoot: &TreeNode{
+				Val: 1,
+				Left: &TreeNode{
+					Val:  2,
+					Left: &TreeNode{Val: 4},
+				},
+				Right: &TreeNode{Val: 3},
+			},
+			want: false,
+		},
+		{
+			name: "multiple nodes with same value",
+			root: &TreeNode{
+				Val: 1,
+				Left: &TreeNode{
+					Val:  2,
+					Left: &TreeNode{Val: 4},
+				},
+				Right: &TreeNode{
+					Val:   2,
+					Left:  &TreeNode{Val: 4},
+					Right: &TreeNode{Val: 5},
+				},
+			},
+			subRoot: &TreeNode{
+				Val:  2,
+				Left: &TreeNode{Val: 4},
+			},
+			want: true,
+		},
+		{
+			name: "deep tree with subtree at bottom",
+			root: &TreeNode{
+				Val: 10,
+				Left: &TreeNode{
+					Val: 5,
+					Left: &TreeNode{
+						Val:   3,
+						Left:  &TreeNode{Val: 1},
+						Right: &TreeNode{Val: 4},
+					},
+				},
+			},
+			subRoot: &TreeNode{
+				Val:   3,
+				Left:  &TreeNode{Val: 1},
+				Right: &TreeNode{Val: 4},
+			},
+			want: true,
+		},
+		{
+			name: "same values but different structure",
+			root: &TreeNode{
+				Val:  1,
+				Left: &TreeNode{Val: 2},
+			},
+			subRoot: &TreeNode{
+				Val:   1,
+				Right: &TreeNode{Val: 2},
+			},
+			want: false,
+		},
+		{
+			name: "negative values",
+			root: &TreeNode{
+				Val:   -10,
+				Left:  &TreeNode{Val: -20},
+				Right: &TreeNode{Val: -5},
+			},
+			subRoot: &TreeNode{
+				Val: -20,
+			},
+			want: true,
+		},
+		{
+			name: "complex tree with no match",
+			root: &TreeNode{
+				Val: 12,
+				Left: &TreeNode{
+					Val:   7,
+					Left:  &TreeNode{Val: 3},
+					Right: &TreeNode{Val: 9},
+				},
+				Right: &TreeNode{
+					Val:   15,
+					Right: &TreeNode{Val: 20},
+				},
+			},
+			subRoot: &TreeNode{
+				Val:  7,
+				Left: &TreeNode{Val: 3},
+				Right: &TreeNode{
+					Val:  9,
+					Left: &TreeNode{Val: 8},
+				},
+			},
+			want: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := isSubtree(tt.root, tt.subRoot)
+			if got != tt.want {
+				t.Errorf("isSubtree() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}