Closest Leaf in a Binary Tree

Closest Leaf in a Binary Tree - Problem

Imagine you're exploring a binary tree and need to find the shortest path from a specific target node to any leaf node. Given the root of a binary tree where every node has a unique value and a target integer k, your task is to return the value of the nearest leaf node to the target k.

The distance is measured by the minimum number of edges you need to traverse to reach any leaf from the target node. Remember, a leaf node is one that has no children (both left and right are null).

Key Points:

You can move both up and down the tree from the target node
Distance is measured in number of edges, not node values
A leaf has no left or right children
All node values are unique

Input & Output

example_1.py — Basic Tree

$ Input: root = [1,3,2], k = 1

› Output: 2

💡 Note: The tree has structure: 1(root) with children 3(left) and 2(right). Both 3 and 2 are leaves. From node 1 (our target k), we can reach leaf 3 in 1 step and leaf 2 in 1 step. Since both have the same distance, we return either one. The answer returns 2.

example_2.py — Target is Leaf

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

› Output: 3

💡 Note: Tree structure: 1→(2,3), 2→(4,null), 4→(5,null), 5→(6,null). Target k=2 is not a leaf (has child 4). Leaves are: 3, 6. Distance from 2 to 3: go up to 1, then down to 3 = 2 steps. Distance from 2 to 6: down through 4→5→6 = 3 steps. Closest leaf is 3.

example_3.py — Target is Leaf Node

$ Input: root = [1,2,3], k = 3

› Output: 3

💡 Note: The tree is 1→(2,3). Target k=3 is already a leaf node (no children). When the target itself is a leaf, the distance is 0, so we return the target value 3.

Constraints

The number of nodes in the tree is in the range [1, 10³]
1 ≤ Node.val ≤ 10³
All Node.val are unique
k is guaranteed to exist in the tree

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 22

The optimal approach converts the binary tree into an undirected graph using adjacency lists, then performs BFS from the target node. This allows movement in all directions (up and down the tree) and guarantees the first leaf found is the closest, achieving O(n) time complexity.

Common Approaches

✓ Brute Force (Find All Leaves + Calculate Distances)

⏱️ Time: O(n²) Space: O(h + l)

First find all leaf nodes in the tree, then for each leaf, calculate the distance from the target node to that leaf by finding their Lowest Common Ancestor (LCA) and summing distances.

Graph Conversion + BFS

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

First pass: build an undirected graph representation of the tree using adjacency lists. Second pass: perform BFS from the target node to find the closest leaf node.

Brute Force (Find All Leaves + Calculate Distances) — Algorithm Steps

Find the target node in the tree
Collect all leaf nodes
For each leaf, find LCA with target node
Calculate distance as: distance(target to LCA) + distance(LCA to leaf)
Return the leaf with minimum distance

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Target Node

Locate the target node k in the tree

Collect All Leaves

Traverse tree to find all leaf nodes

Calculate Distances

For each leaf, find LCA with target and sum distances

Return Minimum

Return the leaf with minimum distance to target

Code -

solution.c — C

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

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

struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

struct TreeNode* parseTree(char* s) {
    if (strcmp(s, "[]") == 0) {
        return NULL;
    }
    
    int len = strlen(s);
    s[len-1] = '\0';
    s++;
    
    char* token = strtok(s, ",");
    if (!token) return NULL;
    
    struct TreeNode* root = createNode(atoi(token));
    struct TreeNode* queue[1000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    while (front < rear && (token = strtok(NULL, ",")) != NULL) {
        struct TreeNode* node = queue[front++];
        
        if (strcmp(token, "null") != 0) {
            node->left = createNode(atoi(token));
            queue[rear++] = node->left;
        }
        
        token = strtok(NULL, ",");
        if (token && strcmp(token, "null") != 0) {
            node->right = createNode(atoi(token));
            queue[rear++] = node->right;
        }
    }
    
    return root;
}

struct TreeNode* findNode(struct TreeNode* node, int target) {
    if (!node) return NULL;
    if (node->val == target) return node;
    struct TreeNode* left = findNode(node->left, target);
    if (left) return left;
    return findNode(node->right, target);
}

void collectLeaves(struct TreeNode* node, struct TreeNode** leaves, int* count) {
    if (!node) return;
    if (!node->left && !node->right) {
        leaves[(*count)++] = node;
        return;
    }
    collectLeaves(node->left, leaves, count);
    collectLeaves(node->right, leaves, count);
}

struct TreeNode* findLCA(struct TreeNode* node, struct TreeNode* p, struct TreeNode* q) {
    if (!node || node == p || node == q) return node;
    struct TreeNode* left = findLCA(node->left, p, q);
    struct TreeNode* right = findLCA(node->right, p, q);
    if (left && right) return node;
    return left ? left : right;
}

int distanceToNode(struct TreeNode* node, struct TreeNode* target) {
    if (!node) return -1;
    if (node == target) return 0;
    int leftDist = distanceToNode(node->left, target);
    if (leftDist >= 0) return leftDist + 1;
    int rightDist = distanceToNode(node->right, target);
    if (rightDist >= 0) return rightDist + 1;
    return -1;
}

int findClosestLeaf(struct TreeNode* root, int k) {
    struct TreeNode* targetNode = findNode(root, k);
    struct TreeNode* leaves[1000];
    int leafCount = 0;
    collectLeaves(root, leaves, &leafCount);
    
    int minDistance = INT_MAX;
    int result = -1;
    
    for (int i = 0; i < leafCount; i++) {
        struct TreeNode* lca = findLCA(root, targetNode, leaves[i]);
        int dist = distanceToNode(lca, targetNode) + distanceToNode(lca, leaves[i]);
        if (dist < minDistance) {
            minDistance = dist;
            result = leaves[i]->val;
        }
    }
    
    return result;
}

int main() {
    char treeStr[10000];
    int k;
    
    fgets(treeStr, sizeof(treeStr), stdin);
    treeStr[strcspn(treeStr, "\n")] = '\0';
    
    scanf("%d", &k);
    
    struct TreeNode* root = parseTree(treeStr);
    
    if (!root) {
        printf("[]\n");
        return 0;
    }
    
    findClosestLeaf(root, k);
    printf("[]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) to find leaves, O(n) for each leaf to calculate distance via LCA

✓ Linear Growth

Space Complexity

O(h + l)

O(h) for recursion stack, O(l) to store all leaves where l is number of leaves

⚡ Linearithmic Space

47.3K Views

Medium Frequency

~25 min Avg. Time

1.5K 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

Brute Force (Find All Leaves + Calculate Distances) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler