Subtree of Another Tree - Practice Coding Problems

Subtree of Another Tree - Problem

Subtree of Another Tree

Given two binary trees root and subRoot, determine if there exists a subtree within root that has the exact same structure and node values as subRoot.

A subtree is defined as a tree consisting of any node in the original tree and all of its descendants. The tree itself can also be considered its own subtree.

Goal: Return true if such a matching subtree exists, false otherwise.

Example:
If root is [3,4,5,1,2] and subRoot is [4,1,2], then subRoot appears as a subtree starting at node 4 in root, so return true.

Input & Output

example_1.py — Basic Match

$ Input: root = [3,4,5,1,2], subRoot = [4,1,2]

› Output: true

💡 Note: The subtree rooted at node 4 in the main tree has the exact structure [4,1,2] matching subRoot

example_2.py — No Match

$ Input: root = [3,4,5,1,2,null,null,null,null,0], subRoot = [4,1,2]

› Output: false

💡 Note: Although node 4 exists with children 1 and 2, node 2 has an additional child 0, so the structure doesn't match exactly

example_3.py — Single Node Match

$ Input: root = [1,2,3], subRoot = [2]

› Output: true

💡 Note: The single node 2 in the main tree matches the single-node subtree [2]

Visualization

Tap to expand

Understanding the Visualization

Initialize Search

Start from the root of the main tree and prepare to check each node

Check Current Node

At each node, use helper function to compare subtree structure with target

Tree Comparison

Helper function recursively compares node values and structure

Continue or Return

If match found, return true; otherwise, recursively search left and right children

Key Takeaway

🎯 Key Insight: We need two separate recursive functions - one to traverse all possible starting points, and another to perform deep structural comparison between trees.

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

In worst case, we check every node in main tree (m nodes) and for each, compare entire subtree (n nodes)

✓ Linear Growth

Space Complexity

O(max(m, n))

Recursion stack depth is at most the height of the larger tree

⚡ Linearithmic Space

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]
-10⁴ <= Node.val <= 10⁴
Both trees are guaranteed to be valid binary trees

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal approach uses recursive tree traversal with a helper function. For each node in the main tree, we check if it could be the root of our target subtree using tree comparison. The key insight is separating the traversal logic from the comparison logic into two distinct functions.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Subtree Matching	O(m × n)	O(max(m, n))	Check every node in main tree as potential subtree root

Recursive Subtree Matching — Algorithm Steps

Create a helper function to check if two trees are identical
Traverse every node in the main tree
At each node, check if subtree starting there matches target
If match found, return true; otherwise continue searching
Return false if no matching subtree is found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Root

Begin checking from the root of the main tree

Compare Trees

Use helper function to check if current subtree matches target

Recurse if No Match

If no match, recursively check left and right children

Return Result

Return true when match found, false if entire tree searched

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

// Definition for a binary tree node
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

bool isSameTree(struct TreeNode* p, struct TreeNode* q) {
    // Both are NULL
    if (p == NULL && q == NULL) return true;
    
    // One is NULL, other is not
    if (p == NULL || q == NULL) return false;
    
    // Values don't match
    if (p->val != q->val) return false;
    
    // Recursively check both subtrees
    return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}

bool isSubtree(struct TreeNode* root, struct TreeNode* subRoot) {
    if (root == NULL) return false;
    
    // Check if current node starts a matching subtree
    if (isSameTree(root, subRoot)) {
        return true;
    }
    
    // Recursively check left and right subtrees
    return isSubtree(root->left, subRoot) || isSubtree(root->right, subRoot);
}

// Example usage
int main() {
    struct TreeNode* root = createNode(3);
    root->left = createNode(4);
    root->right = createNode(5);
    root->left->left = createNode(1);
    root->left->right = createNode(2);
    
    struct TreeNode* subRoot = createNode(4);
    subRoot->left = createNode(1);
    subRoot->right = createNode(2);
    
    printf("%s\n", isSubtree(root, subRoot) ? "true" : "false"); // true
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

In worst case, we check every node in main tree (m nodes) and for each, compare entire subtree (n nodes)

✓ Linear Growth

Space Complexity

O(max(m, n))

Recursion stack depth is at most the height of the larger tree

⚡ Linearithmic Space

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]
-10⁴ <= Node.val <= 10⁴
Both trees are guaranteed to be valid binary trees

52.3K Views

High Frequency

~18 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Recursive Subtree Matching — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler