Find Nearest Right Node in Binary Tree - Practice Coding Problems

Find Nearest Right Node in Binary Tree - Problem

Find Nearest Right Node in Binary Tree

You're given the root of a binary tree and a specific node u that exists somewhere in the tree. Your task is to find the nearest node to the right of u on the same level.

What does "nearest right node" mean?
- It must be on the same level (depth) as node u
- It must be to the right of u when you traverse the level from left to right
- It should be the immediate next node to the right, not just any node to the right

If u is already the rightmost node on its level, return null.

Example:
Tree: [1,2,3,4,5,6,7], u = 4
Level 2 has nodes: [4,5,6,7]
Node 4's nearest right neighbor is node 5.

Input & Output

example_1.py — Basic Case

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

› Output: 5

💡 Note: Node 4 is at level 2. The nodes at level 2 are [4,5,6,7]. The immediate right neighbor of node 4 is node 5.

example_2.py — Rightmost Node

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

› Output: null

💡 Note: Node 6 is at level 2 and is the rightmost node at that level. Since there's no node to its right, we return null.

example_3.py — Single Node Level

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

› Output: null

💡 Note: Node 1 is at level 0 and is the only node at that level. There's no right neighbor, so return null.

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
1 ≤ Node.val ≤ 10⁵
All node values are unique
u is guaranteed to be a node in the tree

Visualization

Tap to expand

Understanding the Visualization

Row-by-Row Search

An usher guides visitors row by row, left to right, just like BFS

Spot Yourself

When the usher reaches you, you're the target node u

Next Person

The very next person the usher encounters in your row is your right neighbor

End of Row

If you're the last person in your row, there's no right neighbor

Key Takeaway

🎯 Key Insight: BFS naturally processes nodes left-to-right within each level, making it perfect for finding the immediate right neighbor!

Asked in

f Facebook 45 a Amazon 38 ⊞ Microsoft 32 G Google 28

The optimal approach uses BFS level-order traversal to process the tree level by level. When we find the target node u, we immediately check if there's a next node in the current level being processed. This gives us O(n) time complexity with early termination and O(w) space complexity where w is the maximum width of the tree.

Common Approaches

Approach	Time	Space	Notes
✓ BFS Level-Order Traversal (Optimal)	O(n)	O(w)	Use BFS to traverse level by level and return the next node after finding target
Brute Force (DFS + Level Grouping)	O(n)	O(n)	Collect all nodes by level, then search for the target's right neighbor

BFS Level-Order Traversal (Optimal) — Algorithm Steps

Initialize a queue with the root node
Process nodes level by level using BFS
When processing a level, check if current node is target u
If found, return the next node in the same level batch, or null if u is last

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Queue

Start with root in queue

Process Level

Process all nodes at current level

Find Target

When target found, return next node in queue

Early Termination

Stop processing once answer is found

Code -

solution.c — C

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

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

struct Queue {
    struct TreeNode** items;
    int front, rear, size, capacity;
};

struct Queue* createQueue(int capacity) {
    struct Queue* queue = (struct Queue*)malloc(sizeof(struct Queue));
    queue->capacity = capacity;
    queue->front = queue->size = 0;
    queue->rear = capacity - 1;
    queue->items = (struct TreeNode**)malloc(capacity * sizeof(struct TreeNode*));
    return queue;
}

void enqueue(struct Queue* queue, struct TreeNode* item) {
    queue->rear = (queue->rear + 1) % queue->capacity;
    queue->items[queue->rear] = item;
    queue->size++;
}

struct TreeNode* dequeue(struct Queue* queue) {
    struct TreeNode* item = queue->items[queue->front];
    queue->front = (queue->front + 1) % queue->capacity;
    queue->size--;
    return item;
}

struct TreeNode* findNearestRightNode(struct TreeNode* root, struct TreeNode* u) {
    if (!root) return NULL;
    
    struct Queue* queue = createQueue(10000);
    enqueue(queue, root);
    
    while (queue->size > 0) {
        int levelSize = queue->size;
        
        for (int i = 0; i < levelSize; i++) {
            struct TreeNode* node = dequeue(queue);
            
            if (node == u) {
                return i < levelSize - 1 ? dequeue(queue) : NULL;
            }
            
            if (node->left) enqueue(queue, node->left);
            if (node->right) enqueue(queue, node->right);
        }
    }
    
    return NULL;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

In worst case visits all nodes, but can terminate early when target is found

✓ Linear Growth

Space Complexity

O(w)

Where w is maximum width of tree (max nodes at any level), for the queue storage

✓ Linear Space

35.6K Views

Medium Frequency

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

BFS Level-Order Traversal (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler