Leaf-Similar Trees - Practice Coding Problems

Leaf-Similar Trees - Problem

Leaf-Similar Trees is a fascinating problem that tests your understanding of binary tree traversal and sequence comparison.

Given two binary trees, we need to determine if they are leaf-similar. Two trees are considered leaf-similar if their leaf value sequences are identical when read from left to right.

The leaf value sequence is formed by collecting all leaf node values in left-to-right order. For example, if a tree has leaves with values [6, 7, 4, 9, 8] when traversed from left to right, that becomes its leaf sequence.

Goal: Return true if the two given trees have the same leaf value sequence, false otherwise.

Input: Two binary tree root nodes root1 and root2
Output: Boolean indicating if the trees are leaf-similar

Input & Output

example_1.py — Basic Similar Trees

$ Input: root1 = [3,5,1,6,2,9,8,null,null,7,4], root2 = [3,5,1,6,7,4,2,null,null,null,null,null,null,9,8]

› Output: true

💡 Note: Both trees have the same leaf sequence [6,7,4,9,8] when read from left to right, even though their internal structure is different.

example_2.py — Different Leaf Sequences

$ Input: root1 = [1,2,3], root2 = [1,3,2]

› Output: false

💡 Note: Tree 1 has leaf sequence [2,3] while tree 2 has leaf sequence [3,2]. The sequences are different, so the trees are not leaf-similar.

example_3.py — Single Node Trees

$ Input: root1 = [1], root2 = [1]

› Output: true

💡 Note: Both trees consist of a single node (which is a leaf) with the same value, so they are leaf-similar.

Constraints

The number of nodes in each tree is in the range [1, 200]
Both trees will have values in the range [0, 200]
Both root1 and root2 are guaranteed to be non-null

Visualization

Tap to expand

Understanding the Visualization

Start at Entrance

Begin at the entrance of both libraries with two assistants

Find Bottom Shelf Books

Each assistant finds the next bottom-shelf book in left-to-right order

Compare Books

Compare the books found by both assistants

Continue or Stop

If books match, continue; if different, libraries are not similar

Key Takeaway

🎯 Key Insight: Just like comparing library bottom shelves, we only need to traverse leaves in order and compare them one-by-one, without storing the entire sequence. Early mismatch detection saves both time and space!

Asked in

a Amazon 45 ⊞ Microsoft 32 G Google 28 f Facebook 21

The optimal approach uses iterators or generators to traverse both trees simultaneously, comparing leaves one-by-one without storing all values. This achieves O(h) space complexity where h is tree height, and allows early termination when a mismatch is found. The key insight is that we don't need to collect all leaves before comparison - we can compare them as we find them.

Common Approaches

Approach	Time	Space	Notes
✓ Generator-Based Comparison (Optimal)	O(min(n, m))	O(h1 + h2)	Use iterators/generators to compare leaves one by one without storing all values

Generator-Based Comparison (Optimal) — Algorithm Steps

Create iterators/generators for both trees that yield leaves in order
Simultaneously iterate through both trees
Compare each pair of leaves as they're generated
Return false immediately if any pair doesn't match
Return true if all leaves match and both iterators are exhausted

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Iterators

Create iterators for both trees starting from roots

Get Next Leaves

Simultaneously get next leaf from each tree

Compare

Compare leaves immediately, short-circuit on mismatch

Continue

Repeat until both iterators are exhausted or mismatch found

Code -

solution.c — C

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

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

int getNextLeaf(struct TreeNode** stack, int* top) {
    while (*top >= 0) {
        struct TreeNode* node = stack[(*top)--];
        
        if (!node->left && !node->right) {
            return node->val;
        }
        
        if (node->right) stack[++(*top)] = node->right;
        if (node->left) stack[++(*top)] = node->left;
    }
    return -1;
}

bool leafSimilar(struct TreeNode* root1, struct TreeNode* root2) {
    struct TreeNode* stack1[1000];
    struct TreeNode* stack2[1000];
    int top1 = 0, top2 = 0;
    
    stack1[0] = root1;
    stack2[0] = root2;
    
    while (top1 >= 0 && top2 >= 0) {
        int leaf1 = getNextLeaf(stack1, &top1);
        int leaf2 = getNextLeaf(stack2, &top2);
        
        if (leaf1 != leaf2) return false;
    }
    
    return top1 == -1 && top2 == -1;
}

Time & Space Complexity

Time Complexity

⏱️

O(min(n, m))

Best case when trees differ early, worst case O(n + m) when trees are identical

✓ Linear Growth

Space Complexity

O(h1 + h2)

Space for recursion stack where h1, h2 are heights of the trees

✓ Linear Space

89.4K Views

Medium 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

Generator-Based Comparison (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler