Populating Next Right Pointers in Each Node II

Populating Next Right Pointers in Each Node II - Problem

Given a binary tree with the following structure:

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

Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be set to NULL.

Initially, all next pointers are set to NULL.

Note: This is the general case where the binary tree can be any binary tree (not necessarily a perfect binary tree).

Input & Output

Example 1 — Perfect Binary Tree

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

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

💡 Note: Level 0: 1; Level 1: 2 → 3; Level 2: 4 → 5 → 6 → 7. Each node points to its next right node in the same level.

Example 2 — General Binary Tree

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

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

💡 Note: Level 0: 1; Level 1: 2 → 3; Level 2: 4 → 5 → 7. Node 6 is missing, so 5 connects directly to 7.

Example 3 — Single Node

$ Input: root = [1]

› Output: [1]

💡 Note: Only one node exists, so no next pointers need to be set.

Constraints

The number of nodes in the tree is in the range [0, 6000]
-100 ≤ Node.val ≤ 100

Visualization

Tap to expand

Asked in

M Microsoft 15 A Amazon 12 F Facebook 8 G Google 6

The key insight is to connect nodes level by level using either BFS or by utilizing already established next pointers from the previous level. The optimal approach uses constant space by leveraging existing connections to traverse levels without extra data structures. Time: O(n), Space: O(1) for optimal solution.

Common Approaches

✓ Constant Space Solution

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

Instead of using a queue, utilize the next pointers from the previous level to traverse the current level. This approach connects nodes level by level using only constant extra space by maintaining a connection between levels.

Level Order Traversal (BFS)

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

Perform a breadth-first search to visit nodes level by level. For each level, connect consecutive nodes by setting their next pointers. This approach uses a queue to maintain nodes at each level.

Constant Space Solution — Algorithm Steps

Use current level's next pointers to traverse
Build connections for the next level while traversing current level
Move to next level using established connections

Visualization

Tap to expand

Step-by-Step Walkthrough

Level 0

Start with root, no connections needed

Level 1

Use root to connect its children 2 → 3

Level 2

Use level 1 connections to traverse and connect level 2

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;
};

struct Node* createNode(int val) {
    struct Node* node = (struct Node*)malloc(sizeof(struct Node));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    node->next = NULL;
    return node;
}

struct Node* solution(struct Node* root) {
    if (!root) return root;
    
    struct Node* leftmost = root;
    
    while (leftmost) {
        struct Node* head = leftmost;
        struct Node* prev = NULL;
        leftmost = NULL;
        
        while (head) {
            if (head->left) {
                if (prev) prev->next = head->left;
                else leftmost = head->left;
                prev = head->left;
            }
            if (head->right) {
                if (prev) prev->next = head->right;
                else leftmost = head->right;
                prev = head->right;
            }
            head = head->next;
        }
    }
    
    return root;
}

static int values[6000];
static int isNull[6000];
static int value_count;

int parseArray(char* line) {
    value_count = 0;
    if (strncmp(line, "[]", 2) == 0) return 0;
    
    char* ptr = line + 1;
    while (*ptr && *ptr != ']') {
        while (*ptr && (*ptr == ' ' || *ptr == ',')) ptr++;
        if (*ptr == ']') break;
        if (strncmp(ptr, "null", 4) == 0) {
            values[value_count] = 0;
            isNull[value_count] = 1;
            value_count++;
            ptr += 4;
        } else {
            char* end;
            int val = (int)strtol(ptr, &end, 10);
            values[value_count] = val;
            isNull[value_count] = 0;
            value_count++;
            ptr = end;
        }
    }
    return value_count;
}

struct Node* buildTree() {
    if (value_count == 0 || isNull[0]) return NULL;
    
    static struct Node* queue[6000];
    int front = 0, rear = 0;
    
    struct Node* root = createNode(values[0]);
    queue[rear++] = root;
    int i = 1;
    
    while (front < rear && i < value_count) {
        struct Node* node = queue[front++];
        if (i < value_count && !isNull[i]) {
            node->left = createNode(values[i]);
            queue[rear++] = node->left;
        }
        i++;
        if (i < value_count && !isNull[i]) {
            node->right = createNode(values[i]);
            queue[rear++] = node->right;
        }
        i++;
    }
    return root;
}

void printOutput() {
    if (value_count == 0) {
        printf("[]\n");
        return;
    }
    printf("[");
    for (int i = 0; i < value_count; i++) {
        if (i > 0) printf(",");
        if (isNull[i]) printf("null");
        else printf("%d", values[i]);
    }
    printf("]\n");
}

int main() {
    char line[10000];
    if (fgets(line, sizeof(line), stdin)) {
        char* newline = strchr(line, '\n');
        if (newline) *newline = '\0';
        
        parseArray(line);
        struct Node* root = buildTree();
        solution(root);
        printOutput();
    }
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once to establish connections

✓ Linear Growth

Space Complexity

O(1)

Only uses a few pointer variables, no additional data structures

✓ Linear Space

89.6K Views

Medium Frequency

~25 min Avg. Time

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

Constant Space Solution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler