Populating Next Right Pointers in Each Node

Populating Next Right Pointers in Each Node - Problem

Connect the Dots: Building Horizontal Bridges in a Perfect Binary Tree

Imagine you have a perfect binary tree where every level is completely filled and all leaves are at the same depth. Your task is to connect each node to its immediate right neighbor on the same level.

Each node has a special next pointer that should point to the node immediately to its right on the same level. If there's no right neighbor (like the rightmost node on each level), the next pointer should be NULL.

Node Structure:

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

Goal: Transform a regular perfect binary tree into a horizontally connected tree where you can traverse each level from left to right using the next pointers.

Challenge: Can you solve this without using extra space for a queue or additional data structures?

Input & Output

perfect_tree.py — Complete Perfect Binary Tree

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

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

💡 Note: The tree has 3 levels. After connecting, level 0 has node 1, level 1 has 2->3, and level 2 has 4->5->6->7. The # represents NULL next pointers.

single_node.py — Single Root Node

$ Input: root = [1]

› Output: [1,#]

💡 Note: A single node tree has no siblings to connect to, so its next pointer remains NULL.

empty_tree.py — Empty Tree Edge Case

$ Input: root = []

› Output: []

💡 Note: An empty tree returns as-is with no modifications needed.

Visualization

Tap to expand

Understanding the Visualization

Start at Top

Begin with the root node as our starting point

Connect Current Level

Use existing connections to traverse and connect children

Navigate Horizontally

Move right using next pointers we've already established

Descend to Next Level

Go down to the leftmost child and repeat the process

Key Takeaway

🎯 Key Insight: Transform the tree into a navigation system where each level's connections become the roadmap for efficiently connecting the next level, eliminating the need for extra space!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each node is visited exactly once to set up connections

✓ Linear Growth

Space Complexity

O(1)

No additional space needed beyond a few pointers for navigation

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 2¹² - 1]
-1000 ≤ Node.val ≤ 1000
The tree is guaranteed to be a perfect binary tree
All leaves are on the same level and every parent has two children

Asked in

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

The optimal solution uses existing next pointers from previously connected levels to navigate and connect children, achieving O(1) space complexity. The key insight is that once a level is connected, those connections become a navigation system for efficiently connecting the next level without any additional data structures.

Common Approaches

Approach	Time	Space	Notes
✓ Optimal: Using Existing Next Pointers	O(n)	O(1)	Use previously connected levels to navigate and connect the next level without extra space
Recursive Level Processing	O(n log n)	O(log n)	Use recursion to collect nodes at each level and connect them

Optimal: Using Existing Next Pointers — Algorithm Steps

Start with the root as the leftmost node of level 0
For each level, use the existing next pointers to traverse horizontally
While traversing, connect the children of current nodes
Move to the next level using the leftmost child
Repeat until no more levels exist

Visualization

Tap to expand

Green arrows: Next pointers from previous iteration2. Purple dashes: Connect left child to right child3. Teal dash: Bridge right child to next parent's left childThis eliminates need for queue - we navigate using previously built connections!

Step-by-Step Walkthrough

Start at Root

Begin with root as leftmost of level 0

Connect Children

Use current level to connect children below

Navigate Right

Use next pointers to traverse current level

Go Down

Move to next level using leftmost child

Code -

solution.c — C

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

struct Node {
    int val;
    struct Node* left;
    struct Node* right;
    struct Node* next;
};

struct Node* connect(struct Node* root) {
    if (!root) return root;
    
    // Start with the root as the leftmost node of level 0
    struct Node* leftmost = root;
    
    // Continue until we reach a level with no children
    while (leftmost->left) {
        // Traverse the current level using next pointers
        struct Node* head = leftmost;
        
        while (head) {
            // Connect left child to right child
            head->left->next = head->right;
            
            // Connect right child to next node's left child
            if (head->next) {
                head->right->next = head->next->left;
            }
            
            // Move to next node in current level
            head = head->next;
        }
        
        // Move to next level
        leftmost = leftmost->left;
    }
    
    return root;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each node is visited exactly once to set up connections

✓ Linear Growth

Space Complexity

O(1)

No additional space needed beyond a few pointers for navigation

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 2¹² - 1]
-1000 ≤ Node.val ≤ 1000
The tree is guaranteed to be a perfect binary tree
All leaves are on the same level and every parent has two children

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimal: Using Existing Next Pointers — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler