Closest Leaf in a Binary Tree - Practice Coding Problems

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.

Visualization

Tap to expand

Understanding the Visualization

Map the Building

Convert the tree structure into a bidirectional map where each room (node) knows all its connected rooms (parent and children)

Start Your Search

Begin a systematic search from your current room (target k), exploring all connected rooms level by level

Check Each Room

For each room you enter, check if it's an exit door (leaf node with no children)

Found the Nearest Exit

The first exit door you find is guaranteed to be the closest one due to the level-by-level search

Key Takeaway

🎯 Key Insight: By converting the tree to an undirected graph, we can explore in all directions. BFS guarantees the first exit (leaf) we find is the closest to our starting position.

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(n) to build graph + O(n) for BFS traversal in worst case

✓ Linear Growth

Space Complexity

O(n)

O(n) for adjacency list + O(n) for BFS queue and visited set

⚡ Linearithmic Space

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

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

Approach	Time	Space	Notes
✓ Graph Conversion + BFS	O(n)	O(n)	Convert tree to undirected graph, then BFS from target to find nearest leaf
Brute Force (Find All Leaves + Calculate Distances)	O(n²)	O(h + l)	Find all leaves, then calculate distance from target to each leaf

Graph Conversion + BFS — Algorithm Steps

Convert binary tree to undirected graph using adjacency lists
Find the target node during graph construction
Start BFS from the target node
For each node in BFS, check if it's a leaf
Return the first leaf encountered (guaranteed to be closest)

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Convert tree to undirected graph with adjacency lists

Start BFS

Begin BFS from target node k

Check Each Level

For each node in queue, check if it's a leaf

Return First Leaf

First leaf encountered is guaranteed closest

Code -

solution.c — C

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

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

#define MAX_NODES 1000

struct Graph {
    struct TreeNode* nodes[MAX_NODES];
    struct TreeNode* adj[MAX_NODES][MAX_NODES];
    int adjCount[MAX_NODES];
    int nodeCount;
};

int findNodeIndex(struct Graph* graph, struct TreeNode* node) {
    for (int i = 0; i < graph->nodeCount; i++) {
        if (graph->nodes[i] == node) {
            return i;
        }
    }
    graph->nodes[graph->nodeCount] = node;
    graph->adjCount[graph->nodeCount] = 0;
    return graph->nodeCount++;
}

void buildGraph(struct TreeNode* node, struct TreeNode* parent, 
               struct Graph* graph, struct TreeNode** targetNode, int k) {
    if (!node) return;
    
    if (node->val == k) {
        *targetNode = node;
    }
    
    int nodeIdx = findNodeIndex(graph, node);
    
    if (parent) {
        int parentIdx = findNodeIndex(graph, parent);
        graph->adj[nodeIdx][graph->adjCount[nodeIdx]++] = parent;
        graph->adj[parentIdx][graph->adjCount[parentIdx]++] = node;
    }
    
    buildGraph(node->left, node, graph, targetNode, k);
    buildGraph(node->right, node, graph, targetNode, k);
}

int findClosestLeaf(struct TreeNode* root, int k) {
    struct Graph graph = {0};
    struct TreeNode* targetNode = NULL;
    
    // Step 1: Build undirected graph
    buildGraph(root, NULL, &graph, &targetNode, k);
    
    // Step 2: BFS from target to find closest leaf
    struct TreeNode* queue[MAX_NODES];
    bool visited[MAX_NODES] = {false};
    int front = 0, rear = 0;
    
    int targetIdx = findNodeIndex(&graph, targetNode);
    queue[rear++] = targetNode;
    visited[targetIdx] = true;
    
    while (front < rear) {
        struct TreeNode* node = queue[front++];
        
        // Check if current node is a leaf
        if (!node->left && !node->right) {
            return node->val;
        }
        
        // Add all unvisited neighbors
        int nodeIdx = findNodeIndex(&graph, node);
        for (int i = 0; i < graph.adjCount[nodeIdx]; i++) {
            struct TreeNode* neighbor = graph.adj[nodeIdx][i];
            int neighborIdx = findNodeIndex(&graph, neighbor);
            if (!visited[neighborIdx]) {
                visited[neighborIdx] = true;
                queue[rear++] = neighbor;
            }
        }
    }
    
    return -1; // Should never reach here
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(n) to build graph + O(n) for BFS traversal in worst case

✓ Linear Growth

Space Complexity

O(n)

O(n) for adjacency list + O(n) for BFS queue and visited set

⚡ Linearithmic Space

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Graph Conversion + BFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler