Find Leaves of Binary Tree - Practice Coding Problems

Find Leaves of Binary Tree - Problem

Find Leaves of Binary Tree challenges you to simulate a unique tree traversal pattern that peels away layers of a binary tree from the outside in.

Given the root of a binary tree, you need to collect nodes in a very specific way:

Identify all leaf nodes (nodes with no children)
Collect them into a group
Remove them from the tree
Repeat until the tree is completely empty

The goal is to return a List<List<Integer>> where each inner list contains the values of nodes removed in each iteration. This creates a beautiful onion-like peeling effect where we progressively remove outer layers until only the core remains.

Example: For a tree [1,2,3,4,5], we first remove leaves [4,5,3], then [2], and finally [1].

Input & Output

example_1.py — Basic Binary Tree

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

› Output: [[4,5,3],[2],[1]]

💡 Note: First removal: leaves 4,5,3 (nodes with no children). Second removal: leaf 2 (after 4,5 removed). Third removal: leaf 1 (the root, now alone).

example_2.py — Single Node

$ Input: root = [1]

› Output: [[1]]

💡 Note: Tree has only one node which is both root and leaf, so it gets removed in the first iteration.

example_3.py — Linear Tree

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

› Output: [[4],[3],[2],[1]]

💡 Note: This creates a left-skewed tree. Each level has only one node, so removal happens one node at a time from bottom to top.

Visualization

Tap to expand

Understanding the Visualization

Identify Heights

Calculate each node's height: distance from being a leaf node

Group by Height

Nodes with same height belong to the same removal layer

Collect Results

Height 0 = first removal, height 1 = second removal, etc.

Key Takeaway

🎯 Key Insight: Instead of actually removing nodes multiple times, calculate each node's 'height' from leaves once and group them accordingly - this transforms an O(n²) problem into O(n)!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single DFS traversal visits each node exactly once

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, plus O(n) for result storage

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [1, 100]
Each node has a unique value
Node values are in the range [-100, 100]
The tree is a valid binary tree

Asked in

in LinkedIn 35 G Google 28 a Amazon 22 ⊞ Microsoft 18

The optimal solution uses height-based DFS traversal to group nodes by their distance from leaves. Instead of repeatedly removing nodes, we calculate each node's height (leaves have height 0) and directly place values in the corresponding result group. This achieves O(n) time complexity with a single tree traversal, making it significantly more efficient than the brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Height-Based DFS (Optimal)	O(n)	O(h)	Calculate each node's height from leaves and group by height in single traversal
Brute Force (Repeated Tree Traversal)	O(n²)	O(h)	Repeatedly traverse the tree to find and collect leaves until empty

Height-Based DFS (Optimal) — Algorithm Steps

Perform DFS traversal of the tree
For each node, calculate its height from leaves
Height = max(left_child_height, right_child_height) + 1
Use height as index to place node value in result array
Leaf nodes (height 0) go in result[0], parents in result[1], etc.
Return the result array containing all groups

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Heights

DFS calculates each node's height: leaves=0, parents=1, etc.

Group by Height

Nodes are automatically placed in correct groups based on height

Result Formation

Height 0 → result[0], Height 1 → result[1], etc.

Code -

solution.c — C

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

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

// Helper function to find max
int max(int a, int b) {
    return (a > b) ? a : b;
}

// DFS function
int dfs(struct TreeNode* node, int** result, int* resultSizes, int* resultCapacity, int* numLevels) {
    if (!node) return -1;
    
    // Calculate height from leaves
    int leftHeight = dfs(node->left, result, resultSizes, resultCapacity, numLevels);
    int rightHeight = dfs(node->right, result, resultSizes, resultCapacity, numLevels);
    int height = max(leftHeight, rightHeight) + 1;
    
    // Ensure result array is large enough
    if (height >= *numLevels) {
        *numLevels = height + 1;
        result[height] = (int*)malloc(1000 * sizeof(int));
        resultSizes[height] = 0;
        resultCapacity[height] = 1000;
    }
    
    // Place node value at its height level
    result[height][resultSizes[height]++] = node->val;
    
    return height;
}

int main() {
    printf("Height-based DFS solution implemented\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single DFS traversal visits each node exactly once

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, plus O(n) for result storage

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [1, 100]
Each node has a unique value
Node values are in the range [-100, 100]
The tree is a valid binary tree

52.0K Views

Medium Frequency

~15 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

Height-Based DFS (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler