Add One Row to Tree

Add One Row to Tree - Problem

Add One Row to Tree

Imagine you're working on a tree visualization tool and need to expand your binary tree by adding a complete row of nodes at a specific depth. This is exactly what this problem asks you to do!

Given the root of a binary tree and two integers val and depth, you need to add a row of nodes with value val at the given depth. The root node is considered to be at depth 1.

The insertion rules are:
• For each non-null node at depth depth - 1, create two new nodes with value val
• The new left node becomes the current node's new left child
• The new right node becomes the current node's new right child
• The original left subtree becomes the new left node's left subtree
• The original right subtree becomes the new right node's right subtree
• Special case: If depth == 1, create a new root with value val and make the original tree its left subtree

Return the root of the modified tree.

Input & Output

example_1.py — Basic insertion at depth 2

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

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

💡 Note: We insert two nodes with value 1 at depth 2. The node with value 4 gets two new children (both with value 1). The original left subtree [2,3,1] becomes the left subtree of the new left child, and the original right subtree [6,5] becomes the right subtree of the new right child.

example_2.py — Insertion at root level

$ Input: root = [4,2,null,3,1], val = 1, depth = 1

› Output: [1,4,null,2,null,3,1]

💡 Note: When depth = 1, we create a new root with value 1 and make the original tree its left subtree. The original root [4,2,null,3,1] becomes the left child of the new root.

example_3.py — Deep insertion

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

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

💡 Note: Insert at depth 3 means we add new nodes as children of all nodes at depth 2. Nodes 2 and 6 each get two new children with value 1, and their original children get connected appropriately.

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
The depth of the tree is in the range [1, 10⁴]
-100 ≤ Node.val ≤ 100
-10⁵ ≤ val ≤ 10⁵
1 ≤ depth ≤ the depth of tree + 1

Visualization

Tap to expand

Asked in

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

The optimal approach uses single-pass DFS traversal with depth tracking. We recursively traverse the tree while keeping track of the current depth. When we reach nodes at depth - 1, we insert new nodes with the target value and reconnect the original subtrees appropriately. The special case where depth = 1 requires creating a new root. Time complexity is O(n) and space complexity is O(h) where h is the tree height.

Common Approaches

✓ BFS Level-Order Traversal

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

This approach uses BFS (breadth-first search) with a queue to traverse the tree level by level. We process nodes until we reach the target depth-1, then insert the new row for all nodes at that level.

Optimized DFS (One Pass)

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

This approach uses a single depth-first traversal while keeping track of the current depth. When we reach nodes at depth-1, we immediately insert the new row, making it the most efficient solution.

Recursive DFS (Brute Force)

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

This approach uses multiple recursive calls without efficient depth tracking, potentially visiting nodes multiple times to determine their depth and perform insertions.

BFS Level-Order Traversal — Algorithm Steps

Handle the special case where depth == 1
Initialize a queue with root and level counter
Process nodes level by level using BFS
When current level equals target depth - 1, insert new nodes
For each node at target level, create two new children
Connect original subtrees to appropriate new nodes

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Queue

Start with root in queue

Process Levels

Handle one complete level at a time

Reach Target

Stop when reaching depth-1

Insert Row

Add new nodes for all nodes at target level

Code -

solution.c — C

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

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

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

static struct TreeNode* queue[10000];
static int front, rear;

void initQueue() {
    front = rear = 0;
}

void enqueue(struct TreeNode* node) {
    queue[rear++] = node;
}

struct TreeNode* dequeue() {
    return queue[front++];
}

int isEmpty() {
    return front == rear;
}

int size() {
    return rear - front;
}

struct TreeNode* parseTree(char* s) {
    int len = strlen(s);
    if (len <= 2 || strcmp(s, "[]") == 0) return NULL;
    
    // Remove brackets
    s[len-1] = '\0';
    s++;
    
    char* token = strtok(s, ",");
    if (!token) return NULL;
    
    struct TreeNode* root = createNode(atoi(token));
    initQueue();
    enqueue(root);
    
    while (!isEmpty()) {
        struct TreeNode* node = dequeue();
        
        token = strtok(NULL, ",");
        if (token && strcmp(token, "null") != 0) {
            node->left = createNode(atoi(token));
            enqueue(node->left);
        }
        
        token = strtok(NULL, ",");
        if (token && strcmp(token, "null") != 0) {
            node->right = createNode(atoi(token));
            enqueue(node->right);
        }
    }
    
    return root;
}

void serializeTree(struct TreeNode* root, char* result) {
    if (!root) {
        strcpy(result, "[]");
        return;
    }
    
    static char values[50000][20];
    int count = 0;
    
    initQueue();
    enqueue(root);
    
    while (!isEmpty()) {
        struct TreeNode* node = dequeue();
        
        if (node) {
            sprintf(values[count], "%d", node->val);
            enqueue(node->left);
            enqueue(node->right);
        } else {
            strcpy(values[count], "null");
        }
        count++;
    }
    
    // Remove trailing nulls
    while (count > 0 && strcmp(values[count-1], "null") == 0) {
        count--;
    }
    
    strcpy(result, "[");
    for (int i = 0; i < count; i++) {
        if (i > 0) strcat(result, ",");
        strcat(result, values[i]);
    }
    strcat(result, "]");
}

struct TreeNode* addOneRow(struct TreeNode* root, int val, int depth) {
    if (depth == 1) {
        struct TreeNode* newRoot = createNode(val);
        newRoot->left = root;
        return newRoot;
    }
    
    initQueue();
    enqueue(root);
    int currentDepth = 1;
    
    while (!isEmpty() && currentDepth < depth - 1) {
        int levelSize = size();
        
        for (int i = 0; i < levelSize; i++) {
            struct TreeNode* node = dequeue();
            
            if (node->left) {
                enqueue(node->left);
            }
            if (node->right) {
                enqueue(node->right);
            }
        }
        currentDepth++;
    }
    
    while (!isEmpty()) {
        struct TreeNode* node = dequeue();
        
        struct TreeNode* oldLeft = node->left;
        struct TreeNode* oldRight = node->right;
        
        node->left = createNode(val);
        node->right = createNode(val);
        node->left->left = oldLeft;
        node->right->right = oldRight;
    }
    
    return root;
}

int main() {
    static char treeStr[10000];
    int val, depth;
    
    fgets(treeStr, sizeof(treeStr), stdin);
    treeStr[strcspn(treeStr, "\n")] = 0; // Remove newline
    
    scanf("%d", &val);
    scanf("%d", &depth);
    
    // Make a copy for parsing since strtok modifies the string
    static char treeCopy[10000];
    strcpy(treeCopy, treeStr);
    
    struct TreeNode* root = parseTree(treeCopy);
    struct TreeNode* result = addOneRow(root, val, depth);
    
    static char output[50000];
    serializeTree(result, output);
    printf("%s\n", output);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

In worst case, visit all nodes up to target depth

⚠ Quadratic Growth

Space Complexity

O(w)

Queue space proportional to maximum width w of tree at any level

✓ Linear Space

89.4K Views

Medium Frequency

~15 min Avg. Time

1.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

BFS Level-Order Traversal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler