Subtree of Another Tree

Subtree of Another Tree - Problem

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.

Input & Output

Example 1 — Basic Subtree 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 same structure and values as subRoot: both have 4 as root with left child 1 and right child 2

Example 2 — No Match Found

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

› Output: false

💡 Note: Although node 4 exists in main tree, the subtree rooted at 4 has an additional node 0 under node 2, so it doesn't exactly match subRoot

Example 3 — Entire Tree Match

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

› Output: true

💡 Note: The entire main tree matches the subRoot exactly - a tree is considered a subtree of itself

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⁴ ≤ root.val ≤ 10⁴
-10⁴ ≤ subRoot.val ≤ 10⁴

Visualization

Tap to expand

Asked in

f Facebook 15 a Amazon 12 M Microsoft 8 G Google 6

The key insight is that a subtree must match exactly at every corresponding node. The brute force approach checks every node as a potential subtree root (O(m×n) time), while the string serialization approach converts trees to unique strings and uses substring matching (O(m+n) time, O(m+n) space).

Common Approaches

✓ Brute Force DFS Comparison

⏱️ Time: O(m × n) Space: O(max(h₁, h₂))

For each node in the main tree, recursively check if the subtree rooted at that node matches the target subtree completely. This involves a helper function to compare two trees for exact equality.

String Serialization Approach

⏱️ Time: O(m + n) Space: O(m + n)

Serialize both trees into unique string representations using preorder traversal, then check if the subtree's serialization appears as a substring in the main tree's serialization. This avoids redundant tree comparisons.

Brute Force DFS Comparison — Algorithm Steps

Traverse each node in main tree
At each node, check if subtree starting here matches target
Use helper function to compare trees node by node

Visualization

Tap to expand

Step-by-Step Walkthrough

Visit Node 3

Check if subtree starting at 3 matches target

Visit Node 4

Check if subtree starting at 4 matches target

Match Found

Subtree at node 4 matches the target subtree

Code -

solution.c — C

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

struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

bool isSameTree(struct TreeNode* s, struct TreeNode* t) {
    if (!s && !t) return true;
    if (!s || !t) return false;
    return s->val == t->val && isSameTree(s->left, t->left) && isSameTree(s->right, t->right);
}

bool solution(struct TreeNode* root, struct TreeNode* subRoot) {
    if (!root) return false;
    
    if (isSameTree(root, subRoot)) return true;
    
    return solution(root->left, subRoot) || solution(root->right, subRoot);
}

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;
}

struct TreeNode* buildTree(int* arr, int* nulls, int size) {
    if (size == 0 || nulls[0]) return NULL;
    
    struct TreeNode* root = createNode(arr[0]);
    struct TreeNode** queue = (struct TreeNode**)malloc(size * sizeof(struct TreeNode*));
    int front = 0, rear = 0;
    queue[rear++] = root;
    int i = 1;
    
    while (front < rear && i < size) {
        struct TreeNode* node = queue[front++];
        
        if (i < size && !nulls[i]) {
            node->left = createNode(arr[i]);
            queue[rear++] = node->left;
        }
        i++;
        
        if (i < size && !nulls[i]) {
            node->right = createNode(arr[i]);
            queue[rear++] = node->right;
        }
        i++;
    }
    
    free(queue);
    return root;
}

int parseArray(char* line, int* arr, int* nulls) {
    int count = 0;
    const char* p = line;
    
    // Find the opening bracket
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        // Check for null
        if (strncmp(p, "null", 4) == 0) {
            nulls[count] = 1;
            arr[count] = 0;
            p += 4;
        } else {
            nulls[count] = 0;
            char* endptr;
            arr[count] = (int)strtol(p, &endptr, 10);
            p = endptr;
        }
        count++;
    }
    
    return count;
}

int main() {
    char line1[1000], line2[1000];
    static int rootArr[1000], subRootArr[1000];
    static int rootNulls[1000], subRootNulls[1000];
    
    if (fgets(line1, sizeof(line1), stdin) == NULL) return 1;
    if (fgets(line2, sizeof(line2), stdin) == NULL) return 1;
    
    int rootSize = parseArray(line1, rootArr, rootNulls);
    int subRootSize = parseArray(line2, subRootArr, subRootNulls);
    
    struct TreeNode* root = buildTree(rootArr, rootNulls, rootSize);
    struct TreeNode* subRoot = buildTree(subRootArr, subRootNulls, subRootSize);
    
    bool result = solution(root, subRoot);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

For each of m nodes in main tree, we may compare with all n nodes of subtree

✓ Linear Growth

Space Complexity

O(max(h₁, h₂))

Recursion stack depth limited by height of taller tree

✓ Linear Space

189.0K Views

Medium Frequency

~15 min Avg. Time

2.9K 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force DFS Comparison — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler