Same Tree - Practice Coding Problems

Same Tree - Problem

Same Tree - Determine if two binary trees are identical

You are given the roots of two binary trees p and q. Your task is to write a function that determines whether these two trees are exactly the same.

Two binary trees are considered identical if:
• They have the same structure (same shape and node positions)
• All corresponding nodes have the same values
• Both trees have nodes in the exact same positions

This is a fundamental tree comparison problem that tests your understanding of tree traversal and recursive thinking. The challenge lies in efficiently comparing both structure and values simultaneously.

Input & Output

example_1.py — Identical Trees

$ Input: p = [1,2,3], q = [1,2,3]

› Output: true

💡 Note: Both trees have the same structure and node values: root=1 with left child=2 and right child=3

example_2.py — Different Structure

$ Input: p = [1,2], q = [1,null,2]

› Output: false

💡 Note: Tree p has node 2 as left child of root, while tree q has node 2 as right child of root - different structures

example_3.py — Different Values

$ Input: p = [1,2,1], q = [1,1,2]

› Output: false

💡 Note: Trees have same structure but different values: p has left=2,right=1 while q has left=1,right=2

Constraints

The number of nodes in both trees is in the range [0, 100]
-10⁴ ≤ Node.val ≤ 10⁴
Both trees can be empty (null)

Visualization

Tap to expand

Understanding the Visualization

Start at Roots

Compare the founding ancestors of both family trees

Check Left Branches

Move to the left family line and compare corresponding members

Check Right Branches

Move to the right family line and compare corresponding members

Recursive Comparison

Continue this process for each sub-family until all branches are checked

Key Takeaway

🎯 Key Insight: By comparing nodes simultaneously during traversal, we achieve optimal performance with early termination when differences are found, avoiding unnecessary computations and extra space for serialization.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 Apple 28

The optimal solution uses recursive DFS to simultaneously traverse both trees, comparing corresponding nodes at each step. This approach achieves O(min(n,m)) time complexity with early termination and O(min(h1,h2)) space complexity for the recursion stack. The key insight is that we don't need to store tree data - we can compare nodes directly during traversal.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive DFS Comparison (Optimal)	O(min(n, m))	O(min(h1, h2))	Recursively compare corresponding nodes in both trees simultaneously

Recursive DFS Comparison (Optimal) — Algorithm Steps

Base case: If both nodes are null, trees match at this position
If one node is null and other isn't, trees don't match
If both nodes exist but have different values, trees don't match
Recursively check left subtrees and right subtrees
Return true only if both subtrees match

Visualization

Tap to expand

Step-by-Step Walkthrough

Compare Roots

Check if root values match (1 == 1 ✓)

Compare Left Children

Recursively check left subtrees (2 == 2 ✓)

Compare Right Children

Recursively check right subtrees (3 == 3 ✓)

All Match

Since all corresponding nodes match, trees are identical

Code -

solution.c — C

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

bool isSameTree(struct TreeNode* p, struct TreeNode* q) {
    // Base case: both nodes are NULL
    if (!p && !q) {
        return true;
    }
    
    // One is NULL, other is not
    if (!p || !q) {
        return false;
    }
    
    // Both nodes exist, check value and recurse
    if (p->val != q->val) {
        return false;
    }
    
    return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}

Time & Space Complexity

Time Complexity

⏱️

O(min(n, m))

We visit each node at most once, and stop early if trees differ. In worst case, visit all nodes of smaller tree

✓ Linear Growth

Space Complexity

O(min(h1, h2))

Recursion stack depth equals minimum height of the two trees due to early termination

⚡ Linearithmic Space

125.0K Views

High Frequency

~15 min Avg. Time

2.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

Constraints

Visualization

Related Problems

Common Approaches

Recursive DFS Comparison (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler