Find Nearest Right Node in Binary Tree

Find Nearest Right Node in Binary Tree - Problem

Given the root of a binary tree and a node u in the tree, return the nearest node on the same level that is to the right of u, or return null if u is the rightmost node in its level.

The tree is guaranteed to contain the given node u.

Input & Output

Example 1 — Basic Right Neighbor

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

› Output: 5

💡 Note: Node 4 is at level 2 with nodes [4,5,6,7]. The nearest right node is 5.

Example 2 — Rightmost Node

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

› Output: null

💡 Note: Node 7 is the rightmost node at level 2, so there's no right neighbor.

Example 3 — Root Level

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

› Output: null

💡 Note: Node 1 is at level 0 by itself, so there's no right neighbor.

Constraints

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

Visualization

Tap to expand

Asked in

f Facebook 15 M Microsoft 12 a Amazon 8 G Google 6

The key insight is to use BFS level-order traversal to process nodes level by level. When we find the target node, we can immediately check if there's a next node in the same level. Best approach is Level-Order BFS with Time: O(n), Space: O(w) where w is tree width.

Common Approaches

✓ Optimized

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

DFS with Level Mapping

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

First traverse the tree to build a map of all nodes at each level, then search for the target node and return the next node in the same level if it exists.

Level-Order BFS

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

Process the tree level by level using BFS. When we encounter the target node u, check if there's a next node in the current level being processed.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

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

typedef struct {
    TreeNode** nodes;
    int size;
    int capacity;
} NodeList;

typedef struct {
    NodeList* levels[1000];
    int maxLevel;
} LevelMap;

NodeList* createNodeList() {
    NodeList* list = malloc(sizeof(NodeList));
    list->capacity = 100;
    list->nodes = malloc(sizeof(TreeNode*) * list->capacity);
    list->size = 0;
    return list;
}

void addNode(NodeList* list, TreeNode* node) {
    if (list->size >= list->capacity) {
        list->capacity *= 2;
        list->nodes = realloc(list->nodes, sizeof(TreeNode*) * list->capacity);
    }
    list->nodes[list->size++] = node;
}

void dfs(TreeNode* node, int level, LevelMap* levels) {
    if (node == NULL) return;
    
    if (levels->levels[level] == NULL) {
        levels->levels[level] = createNodeList();
    }
    if (level > levels->maxLevel) {
        levels->maxLevel = level;
    }
    
    addNode(levels->levels[level], node);
    dfs(node->left, level + 1, levels);
    dfs(node->right, level + 1, levels);
}

TreeNode* solution(TreeNode* root, TreeNode* u) {
    if (root == NULL) return NULL;
    
    LevelMap levels = {0};
    levels.maxLevel = -1;
    
    dfs(root, 0, &levels);
    
    for (int level = 0; level <= levels.maxLevel; level++) {
        if (levels.levels[level] == NULL) continue;
        NodeList* nodes = levels.levels[level];
        for (int i = 0; i < nodes->size; i++) {
            if (nodes->nodes[i] == u) {
                if (i + 1 < nodes->size) {
                    return nodes->nodes[i + 1];
                }
                return NULL;
            }
        }
    }
    
    return NULL;
}

TreeNode* buildTree(int* arr, int size) {
    if (size == 0 || arr[0] == -1) return NULL;
    
    TreeNode* root = malloc(sizeof(TreeNode));
    root->val = arr[0];
    root->left = root->right = NULL;
    
    TreeNode* queue[1000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    int i = 1;
    
    while (front < rear && i < size) {
        TreeNode* node = queue[front++];
        
        if (i < size && arr[i] != -1) {
            node->left = malloc(sizeof(TreeNode));
            node->left->val = arr[i];
            node->left->left = node->left->right = NULL;
            queue[rear++] = node->left;
        }
        i++;
        
        if (i < size && arr[i] != -1) {
            node->right = malloc(sizeof(TreeNode));
            node->right->val = arr[i];
            node->right->left = node->right->right = NULL;
            queue[rear++] = node->right;
        }
        i++;
    }
    
    return root;
}

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

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int arr[100];
    int size = 0;
    
    char* token = strtok(line, "[],\n ");
    while (token != NULL) {
        if (strcmp(token, "null") == 0) {
            arr[size++] = -1;
        } else {
            arr[size++] = atoi(token);
        }
        token = strtok(NULL, "[],\n ");
    }
    
    fgets(line, sizeof(line), stdin);
    int uVal = atoi(line);
    
    TreeNode* root = buildTree(arr, size);
    TreeNode* u = findNode(root, uVal);
    TreeNode* result = solution(root, u);
    
    if (result == NULL) {
        printf("null\n");
    } else {
        printf("%d\n", result->val);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

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