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.

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

Visualization

Tap to expand

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

✓ Optimal: Using Existing Next Pointers

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

The optimal solution leverages the fact that once we've connected a level, we can use those next pointers to efficiently traverse that level and connect the children. This eliminates the need for any additional data structures.

Recursive Level Processing

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

A recursive approach that processes the tree level by level. For each level, we collect all nodes at that depth, then connect them horizontally. This is less efficient as it requires multiple passes through the tree.

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>
#include <string.h>

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

// Create a new node
struct Node* newNode(int val) {
    struct Node* node = (struct Node*)malloc(sizeof(struct Node));
    node->val = val;
    node->left = node->right = node->next = NULL;
    return node;
}

// Connect next right pointers (O(1) space, uses existing next pointers)
struct Node* connect(struct Node* root) {
    if (!root) return root;

    struct Node* leftmost = root;

    while (leftmost->left) {
        struct Node* head = leftmost;

        while (head) {
            // Connect left child to right child of same parent
            head->left->next = head->right;

            // Connect right child to left child of next parent
            if (head->next) {
                head->right->next = head->next->left;
            }

            head = head->next;
        }

        // Move to the next level
        leftmost = leftmost->left;
    }

    return root;
}

// Build perfect binary tree from level-order array (1-indexed values, '#' = null)
struct Node* buildTree(char values[][20], int count) {
    if (count == 0 || strcmp(values[0], "#") == 0) return NULL;

    struct Node** nodes = (struct Node**)malloc(count * sizeof(struct Node*));
    for (int i = 0; i < count; i++) nodes[i] = NULL;

    nodes[0] = newNode(atoi(values[0]));

    for (int i = 1; i < count; i++) {
        if (strcmp(values[i], "#") == 0) continue;
        nodes[i] = newNode(atoi(values[i]));
        int parent = (i - 1) / 2;
        if (nodes[parent]) {
            if (i % 2 == 1) nodes[parent]->left = nodes[i];
            else             nodes[parent]->right = nodes[i];
        }
    }

    struct Node* root = nodes[0];
    free(nodes);
    return root;
}

// Serialize tree in level-order, printing val or '#', separated by commas, ending with comma
void serializeWithNext(struct Node* root) {
    if (!root) { printf("#,"); return; }

    // BFS using a simple queue
    struct Node** queue = (struct Node**)malloc(10000 * sizeof(struct Node*));
    int front = 0, back = 0;
    queue[back++] = root;

    int first = 1;
    while (front < back) {
        struct Node* curr = queue[front++];
        if (!first) printf(",");
        first = 0;
        if (curr == NULL) {
            printf("#");
        } else {
            printf("%d", curr->val);
            queue[back++] = curr->left;
            queue[back++] = curr->right;
        }
    }
    printf(",");
    free(queue);
}

// Serialize using next pointers (level order via next pointers)
// Output format: val,#, val,#, ... where # marks end of each level
void serializeUsingNext(struct Node* root) {
    if (!root) return;

    struct Node* leftmost = root;
    int first = 1;

    while (leftmost) {
        struct Node* curr = leftmost;
        while (curr) {
            if (!first) printf(",");
            first = 0;
            printf("%d", curr->val);
            curr = curr->next;
        }
        // Print '#' at end of each level
        printf(",#");
        leftmost = leftmost->left;
    }
    printf(",");
}

int main() {
    char line[100000];
    if (!fgets(line, sizeof(line), stdin)) return 1;

    // Remove newline
    line[strcspn(line, "\n")] = 0;

    // Parse array like [1,2,3,4,5,6,7]
    char* p = line;
    while (*p == ' ' || *p == '[') p++;

    char values[10000][20];
    int count = 0;

    while (*p && *p != ']') {
        int i = 0;
        while (*p && *p != ',' && *p != ']') {
            values[count][i++] = *p++;
        }
        values[count][i] = '\0';
        count++;
        if (*p == ',') p++;
    }

    struct Node* root = buildTree(values, count);
    connect(root);
    serializeUsingNext(root);
    printf("\n");

    return 0;
}

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

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

Constraints

Visualization

Related Problems

Common Approaches

Optimal: Using Existing Next Pointers — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler