Add One Row to Tree - Practice Coding Problems

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.

Visualization

Tap to expand

Understanding the Visualization

Identify Target Level

Find all nodes at depth-1 where new children will be added

Preserve Original Children

Store references to existing left and right subtrees

Insert New Nodes

Create two new nodes with target value as new children

Reconnect Subtrees

Attach original left subtree to new left child's left, and original right subtree to new right child's right

Key Takeaway

🎯 Key Insight: Track depth during traversal to identify exactly where to insert the new row, then carefully preserve parent-child relationships by connecting original subtrees to the appropriate sides of new nodes.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once during the traversal

✓ Linear Growth

Space Complexity

O(h)

Recursion stack space proportional to tree height h

✓ Linear Space

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

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

Approach	Time	Space	Notes
✓ BFS Level-Order Traversal	O(n)	O(w)	Use breadth-first search to process nodes level by level until target depth
Recursive DFS (Brute Force)	O(n²)	O(h)	Recursively traverse and rebuild parts of the tree multiple times
Optimized DFS (One Pass)	O(n)	O(h)	Single recursive traversal with depth tracking for optimal insertion

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>

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

// Simple queue implementation
struct Queue {
    struct TreeNode* nodes[10000];
    int front, rear;
};

void initQueue(struct Queue* q) {
    q->front = q->rear = 0;
}

void enqueue(struct Queue* q, struct TreeNode* node) {
    q->nodes[q->rear++] = node;
}

struct TreeNode* dequeue(struct Queue* q) {
    return q->nodes[q->front++];
}

int isEmpty(struct Queue* q) {
    return q->front == q->rear;
}

int size(struct Queue* q) {
    return q->rear - q->front;
}

struct TreeNode* addOneRow(struct TreeNode* root, int val, int depth) {
    // Special case: inserting at root level
    if (depth == 1) {
        struct TreeNode* newRoot = createNode(val);
        newRoot->left = root;
        return newRoot;
    }
    
    // BFS to find nodes at depth - 1
    struct Queue q;
    initQueue(&q);
    enqueue(&q, root);
    int currentDepth = 1;
    
    while (!isEmpty(&q) && currentDepth < depth - 1) {
        int levelSize = size(&q);
        
        for (int i = 0; i < levelSize; i++) {
            struct TreeNode* node = dequeue(&q);
            
            if (node->left) {
                enqueue(&q, node->left);
            }
            if (node->right) {
                enqueue(&q, node->right);
            }
        }
        currentDepth++;
    }
    
    // Insert new row for all nodes at depth - 1
    while (!isEmpty(&q)) {
        struct TreeNode* node = dequeue(&q);
        
        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;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

In worst case, visit all nodes up to target depth

✓ Linear Growth

Space Complexity

O(w)

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

✓ Linear Space

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

BFS Level-Order Traversal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler