15 Jun 2024•C++ / Python / TypeScript•Easy

Subtree of Another Tree

Collected C++, Python, TypeScript solutions for subtree of another tree. Add a dedicated write-up later if you want deeper notes.

View original LeetCode question

auto-generated entry for Subtree of Another Tree. the solution files are available below.

solution files

C++ subtree-of-another-tree/synced-solution.cpp
Python subtree-of-another-tree/synced-solution.py
TypeScript subtree-of-another-tree/synced-solution.ts

Solution files

Python•subtree-of-another-tree/synced-solution.py

class Solution:
    def isSubtree(self, root: Optional[TreeNode], subRoot: Optional[TreeNode]) -> bool:
        def same_tree(a, b):
            if not a and not b:
                return True
            if not a or not b:
                return False
            return a.val == b.val and same_tree(a.left, b.left) and same_tree(a.right, b.right)

        if not subRoot:
            return True
        if not root:
            return False
        return same_tree(root, subRoot) or self.isSubtree(root.left, subRoot) or self.isSubtree(root.right, subRoot)

C++•subtree-of-another-tree/synced-solution.cpp

class Solution {
public:
    bool isSubtree(TreeNode* root, TreeNode* subRoot) {
        if (!subRoot) {
            return true;
        }
        if (!root) {
            return false;
        }
        return sameTree(root, subRoot) || isSubtree(root->left, subRoot) || isSubtree(root->right, subRoot);
    }

private:
    bool sameTree(TreeNode* a, TreeNode* b) {
        if (!a && !b) {
            return true;
        }
        if (!a || !b) {
            return false;
        }
        return a->val == b->val && sameTree(a->left, b->left) && sameTree(a->right, b->right);
    }
};

TypeScript•subtree-of-another-tree/synced-solution.ts

function isSubtree(root: TreeNode | null, subRoot: TreeNode | null): boolean {
    const sameTree = (a: TreeNode | null, b: TreeNode | null): boolean => {
        if (!a && !b) {
            return true;
        }
        if (!a || !b) {
            return false;
        }
        return a.val === b.val && sameTree(a.left, b.left) && sameTree(a.right, b.right);
    };

    if (!subRoot) {
        return true;
    }
    if (!root) {
        return false;
    }
    return sameTree(root, subRoot) || isSubtree(root.left, subRoot) || isSubtree(root.right, subRoot);
}