Populating Next Right Pointers in Each Node II

Populating Next Right Pointers in Each Node II - Problem

Imagine you're looking at a binary tree from the side, and you want to connect each node to its neighbor on the same level. Given a binary tree with a special structure:

struct Node {
    int val;
    Node *left;
    Node *right;
    Node *next;  // This is what we need to populate!
}

Your task is to populate each next pointer to point to the next right node on the same level. If there's no next right node, the next pointer should be set to NULL.

Key Details:

Initially, all next pointers are set to NULL
Unlike the simpler version, this tree is not guaranteed to be a perfect binary tree
You need to handle any binary tree structure
The connection should create a "linked list" across each level

Goal: Transform the tree so that each level becomes a linked list connected via next pointers, enabling efficient level-by-level traversal.

Input & Output

example_1.py — Perfect Binary Tree

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

› Output: [1,#,2,3,#,4,5,6,7,#] (# represents null next pointer)

💡 Note: Each level becomes a linked list: Level 0: 1→null, Level 1: 2→3→null, Level 2: 4→5→6→7→null

example_2.py — Incomplete Binary Tree

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

› Output: [1,#,2,3,#,4,5,7,#]

💡 Note: Missing node 6 doesn't affect the connections: Level 0: 1→null, Level 1: 2→3→null, Level 2: 4→5→7→null

example_3.py — Single Node

$ Input: root = [1]

› Output: [1,#]

💡 Note: Single node tree: Level 0: 1→null. No other levels exist.

Constraints

The number of nodes in the tree is in the range [0, 6000]
-100 ≤ Node.val ≤ 100
Follow up: You may only use constant extra space
The recursive approach is fine. You may assume implicit stack space does not count as extra space

Visualization

Tap to expand

Understanding the Visualization

Start at Top Floor

Begin with the root node (top floor, single room)

Walk Current Floor

Use existing bridges (next pointers) to walk across the current floor

Build Next Floor Bridges

While walking, connect the children (rooms below) with new bridges

Move Down

Go to the next floor and repeat using the new bridges

Complete

Continue until reaching the bottom floor

Key Takeaway

🎯 Key Insight: The optimal solution leverages the structure it builds (next pointers) to efficiently construct the next level, eliminating the need for extra space while maintaining linear time complexity.

Asked in

f Meta 85 ⊞ Microsoft 72 a Amazon 68 G Google 45 Apple 38 B Bloomberg 32

The optimal solution uses O(1) extra space by leveraging the next pointers established on the current level to efficiently connect nodes on the next level. This approach eliminates the need for queues or hash maps, making it both space and time efficient with O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Level-wise Storage Approach	O(n)	O(n)	Store nodes by level in a hash map, then connect nodes within each level
Level Order Traversal with Queue	O(n)	O(w)	Use BFS with a queue to process nodes level by level and connect them
Optimized Level Linking (Optimal)	O(n)	O(1)	Use previously established next pointers to build connections for the next level

Level-wise Storage Approach — Algorithm Steps

Traverse the tree using DFS and store nodes by level in a hash map
For each level, maintain a list of nodes in left-to-right order
After the first pass, iterate through each level in the hash map
For each level, connect consecutive nodes using their next pointers
Set the last node's next pointer to null for each level

Visualization

Tap to expand

Step-by-Step Walkthrough

DFS Collection

Traverse tree and group nodes by level

Level Storage

Store nodes in hash map by level

Sequential Connection

Connect consecutive nodes within each level

Code -

solution.c — C

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

#define MAX_NODES 5000

struct Node* levelNodes[20][MAX_NODES];  // Assuming max 20 levels
int levelSizes[20] = {0};

void dfs(struct Node* node, int level) {
    if (!node) return;
    
    levelNodes[level][levelSizes[level]++] = node;
    dfs(node->left, level + 1);
    dfs(node->right, level + 1);
}

struct Node* connect(struct Node* root) {
    if (!root) return root;
    
    // Reset level sizes
    for (int i = 0; i < 20; i++) {
        levelSizes[i] = 0;
    }
    
    // First pass: collect nodes by level
    dfs(root, 0);
    
    // Second pass: connect nodes within each level
    for (int level = 0; level < 20; level++) {
        for (int i = 0; i < levelSizes[level] - 1; i++) {
            levelNodes[level][i]->next = levelNodes[level][i + 1];
        }
    }
    
    return root;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

First pass to collect nodes O(n) + second pass to connect them O(n)

✓ Linear Growth

Space Complexity

O(n)

Hash map stores all n nodes grouped by level

⚡ Linearithmic Space

142.4K Views

High Frequency

~25 min Avg. Time

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

Level-wise Storage Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler