All Nodes Distance K in Binary Tree - Practice Coding Problems

All Nodes Distance K in Binary Tree - Problem

Imagine you're standing at a specific node in a binary tree and need to find all nodes that are exactly k steps away from your current position. You can move to parent nodes, left children, or right children - each move counts as one step.

Given the root of a binary tree, a target node value, and an integer k, return an array containing the values of all nodes that are exactly distance k from the target node.

The beauty of this problem is that distance can be measured in any direction - up to parents or down to children!

Example: If target node has value 5 and k=2, you need to find all nodes that require exactly 2 steps to reach from node 5, whether going through parents, children, or a combination of both.

Input & Output

example_1.py — Basic Tree

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

› Output: [7,4,1]

💡 Note: Nodes at distance 2 from target node 5 are: 7 (5→6→7), 4 (5→2→4), and 1 (5→3→1). The path can go through parents or children.

example_2.py — Single Node

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

› Output: []

💡 Note: There are no nodes at distance 3 from the target node 1, since the tree only has one node.

example_3.py — Distance 0

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

› Output: [5]

💡 Note: At distance 0 from target node 5, only the target node itself qualifies.

Visualization

Tap to expand

Understanding the Visualization

Build the Network

Create parent-child connections so every node knows its neighbors

Start Spreading

Begin BFS from target node, like ripples in a pond

Level-by-Level

Each BFS level represents one more step of distance

Collect Results

After k levels, collect all nodes in the current BFS queue

Key Takeaway

🎯 Key Insight: Trees are just restricted graphs. Add parent pointers to enable bidirectional BFS, then distance k becomes k levels of BFS expansion.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single DFS pass to build graph O(n) + BFS from target O(n) in worst case

✓ Linear Growth

Space Complexity

O(n)

Parent mapping O(n) + BFS queue O(w) where w is maximum width of tree

⚡ Linearithmic Space

Constraints

The number of nodes in the tree is in the range [1, 500]
0 ≤ Node.val ≤ 500
All values Node.val are unique
target is the value of one of the nodes in the tree
0 ≤ k ≤ 1000

Asked in

f Facebook 85 a Amazon 72 G Google 68 ⊞ Microsoft 45 Apple 32

The optimal solution uses parent mapping + BFS to convert the tree into an undirected graph, then performs level-order traversal from the target node. Key insight: distance in trees requires bidirectional navigation - we need parent pointers to traverse upward, combined with normal child pointers for downward traversal. Time: O(n), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ DFS with Parent Pointers (Optimal)	O(n)	O(n)	Single DFS pass builds graph and performs distance search simultaneously
Parent Mapping + BFS	O(n)	O(n)	First pass builds parent-child mapping, second pass uses BFS from target
Brute Force (DFS from Every Node)	O(n²)	O(h)	For each node, calculate distance to target and collect nodes at distance k

DFS with Parent Pointers (Optimal) — Algorithm Steps

Use DFS to traverse tree and locate target node
While traversing, build parent pointers for upward navigation
Once target is found, start BFS from target node
Use parent pointers and child pointers to explore in all directions
Collect all nodes at exactly distance k

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Parent Map

DFS traversal creates parent pointers for upward navigation

Level 0: Target

Start BFS from target node (distance 0)

Level 1: Neighbors

Expand to parent and children (distance 1)

Level k: Result

All nodes at distance k are found

Code -

solution.c — C

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

#define MAX_NODES 1000

struct ParentMapEntry {
    struct TreeNode* child;
    struct TreeNode* parent;
};

struct ParentMapEntry parentMap[MAX_NODES];
int parentMapSize = 0;

struct TreeNode* getParent(struct TreeNode* node) {
    for (int i = 0; i < parentMapSize; i++) {
        if (parentMap[i].child == node) {
            return parentMap[i].parent;
        }
    }
    return NULL;
}

void addToParentMap(struct TreeNode* child, struct TreeNode* parent) {
    if (parentMapSize < MAX_NODES) {
        parentMap[parentMapSize].child = child;
        parentMap[parentMapSize].parent = parent;
        parentMapSize++;
    }
}

void buildParents(struct TreeNode* node, struct TreeNode* parent) {
    if (!node) return;
    addToParentMap(node, parent);
    buildParents(node->left, node);
    buildParents(node->right, node);
}

int* distanceK(struct TreeNode* root, struct TreeNode* target, int k, int* returnSize) {
    *returnSize = 0;
    if (!root) return NULL;
    
    parentMapSize = 0;
    buildParents(root, NULL);
    
    struct TreeNode* queue[MAX_NODES];
    struct TreeNode* visited[MAX_NODES];
    int queueSize = 0, visitedSize = 0;
    
    queue[queueSize++] = target;
    visited[visitedSize++] = target;
    
    // Perform k levels of BFS
    for (int level = 0; level < k; level++) {
        if (queueSize == 0) {
            *returnSize = 0;
            return NULL;
        }
        
        int currentLevelSize = queueSize;
        queueSize = 0; // Reset for next level
        
        for (int i = 0; i < currentLevelSize; i++) {
            struct TreeNode* node = queue[i];
            
            struct TreeNode* neighbors[3] = {getParent(node), node->left, node->right};
            
            for (int j = 0; j < 3; j++) {
                if (neighbors[j]) {
                    // Check if already visited (simplified)
                    int alreadyVisited = 0;
                    for (int v = 0; v < visitedSize; v++) {
                        if (visited[v] == neighbors[j]) {
                            alreadyVisited = 1;
                            break;
                        }
                    }
                    
                    if (!alreadyVisited) {
                        visited[visitedSize++] = neighbors[j];
                        queue[queueSize++] = neighbors[j];
                    }
                }
            }
        }
    }
    
    // Collect results
    int* result = (int*)malloc(queueSize * sizeof(int));
    *returnSize = queueSize;
    for (int i = 0; i < queueSize; i++) {
        result[i] = queue[i]->val;
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single DFS pass to build graph O(n) + BFS from target O(n) in worst case

✓ Linear Growth

Space Complexity

O(n)

Parent mapping O(n) + BFS queue O(w) where w is maximum width of tree

⚡ Linearithmic Space

Constraints

The number of nodes in the tree is in the range [1, 500]
0 ≤ Node.val ≤ 500
All values Node.val are unique
target is the value of one of the nodes in the tree
0 ≤ k ≤ 1000

425.6K Views

High Frequency

~18 min Avg. Time

8.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

DFS with Parent Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler