Find Leaves of Binary Tree

Find Leaves of Binary Tree - Problem

Given the root of a binary tree, collect a tree's nodes as if you were doing this:

1. Collect all the leaf nodes, remove all the leaf nodes.

2. Repeat until the tree is empty.

Return a 2D array where each sub-array contains all the nodes removed at each step.

Definition: A leaf is a node with no left and right children.

Input & Output

Example 1 — Standard Tree

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

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

💡 Note: Step 1: Remove leaves [4,5,3]. Step 2: Remove leaves [2]. Step 3: Remove leaves [1].

Example 2 — Single Node

$ Input: root = [1]

› Output: [[1]]

💡 Note: Only one node, which is a leaf, so remove it in the first step.

Example 3 — Linear Tree

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

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

💡 Note: Linear tree: each level has one leaf. Remove 4, then 3, then 2, then 1.

Constraints

The number of nodes in the tree is in the range [1, 100]
-100 ≤ Node.val ≤ 100

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 f Facebook 12

The key insight is that nodes at the same distance from leaves will be removed together. The optimal DFS approach calculates each node's height in one pass and groups them accordingly. Time: O(n), Space: O(h).

Common Approaches

✓ Frequency Count

⏱️ Time: N/A Space: N/A

Brute Force - Simulate Removal

⏱️ Time: O(n²) Space: O(n)

Simulate the actual process by repeatedly traversing the tree to identify leaf nodes, collect them, mark as removed, and repeat until no nodes remain.

DFS Height-Based Grouping

⏱️ Time: O(n) Space: O(h)

Use DFS to calculate each node's height (distance from deepest leaf). Nodes with the same height will be removed in the same step, so group them accordingly.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int** solution(int** matches, int matchesSize, int* matchesColSize, int* returnSize, int** returnColumnSizes) {
    // Use arrays to simulate hash map (assuming player IDs are reasonable)
    int lossCount[100001] = {0}; // Support player IDs up to 100000
    int playerExists[100001] = {0};
    int maxPlayer = 0;
    
    // Single pass to count losses and track players
    for (int i = 0; i < matchesSize; i++) {
        int winner = matches[i][0];
        int loser = matches[i][1];
        
        playerExists[winner] = 1;
        playerExists[loser] = 1;
        lossCount[loser]++;
        
        if (winner > maxPlayer) maxPlayer = winner;
        if (loser > maxPlayer) maxPlayer = loser;
    }
    
    int* noLosses = (int*)malloc(maxPlayer * sizeof(int));
    int* oneLoss = (int*)malloc(maxPlayer * sizeof(int));
    int noLossCount = 0, oneLossCount = 0;
    
    // Categorize players by loss count
    for (int i = 1; i <= maxPlayer; i++) {
        if (playerExists[i]) {
            if (lossCount[i] == 0) {
                noLosses[noLossCount++] = i;
            } else if (lossCount[i] == 1) {
                oneLoss[oneLossCount++] = i;
            }
        }
    }
    
    // Sort results
    qsort(noLosses, noLossCount, sizeof(int), compare);
    qsort(oneLoss, oneLossCount, sizeof(int), compare);
    
    // Prepare return arrays
    int** result = (int**)malloc(2 * sizeof(int*));
    *returnColumnSizes = (int*)malloc(2 * sizeof(int));
    
    result[0] = noLosses;
    result[1] = oneLoss;
    (*returnColumnSizes)[0] = noLossCount;
    (*returnColumnSizes)[1] = oneLossCount;
    *returnSize = 2;
    
    return result;
}

int parseMatches(char* input, int*** matches, int* matchesSize) {
    if (strlen(input) <= 2) {
        *matches = NULL;
        *matchesSize = 0;
        return 0;
    }
    
    // Count matches by counting '[' after first one
    int count = 0;
    for (int i = 1; i < strlen(input); i++) {
        if (input[i] == '[') count++;
    }
    
    *matchesSize = count;
    *matches = (int**)malloc(count * sizeof(int*));
    
    for (int i = 0; i < count; i++) {
        (*matches)[i] = (int*)malloc(2 * sizeof(int));
    }
    
    // Simple parsing
    char* ptr = input + 1; // Skip first '['
    for (int i = 0; i < count; i++) {
        while (*ptr != '[') ptr++; // Find next '['
        ptr++; // Skip '['
        (*matches)[i][0] = atoi(ptr);
        while (*ptr != ',') ptr++; // Find comma
        ptr++; // Skip comma
        (*matches)[i][1] = atoi(ptr);
        while (*ptr != ']') ptr++; // Find ']'
        ptr++; // Skip ']'
    }
    
    return 1;
}

int main() {
    char input[100000];
    if (fgets(input, sizeof(input), stdin)) {
        // Remove newline
        input[strcspn(input, "\n")] = 0;
        
        int** matches;
        int matchesSize;
        
        if (parseMatches(input, &matches, &matchesSize)) {
            int* matchesColSize = (int*)malloc(matchesSize * sizeof(int));
            for (int i = 0; i < matchesSize; i++) matchesColSize[i] = 2;
            
            int returnSize;
            int* returnColumnSizes;
            int** result = solution(matches, matchesSize, matchesColSize, &returnSize, &returnColumnSizes);
            
            printf("[");
            for (int i = 0; i < returnSize; i++) {
                printf("[");
                for (int j = 0; j < returnColumnSizes[i]; j++) {
                    printf("%d", result[i][j]);
                    if (j < returnColumnSizes[i] - 1) printf(",");
                }
                printf("]");
                if (i < returnSize - 1) printf(",");
            }
            printf("]\n");
            
            // Cleanup
            for (int i = 0; i < matchesSize; i++) {
                free(matches[i]);
            }
            free(matches);
            free(matchesColSize);
            free(returnColumnSizes);
            for (int i = 0; i < returnSize; i++) {
                free(result[i]);
            }
            free(result);
        }
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

892 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