Codestin Search App

Complete Binary Tree Inserter - Problem

Imagine you're building a perfect pyramid structure where every level must be completely filled from left to right before starting the next level. This is exactly what a complete binary tree represents!

A complete binary tree is a binary tree where:

Every level is completely filled, except possibly the last level
The last level is filled from left to right
No gaps are allowed in any level

Your task is to design a CBTInserter class that maintains this perfect structure:

CBTInserter(TreeNode root): Initialize with an existing complete binary tree
int insert(int val): Insert a new node while keeping the tree complete, return the parent's value
TreeNode get_root(): Return the root of the tree

The challenge is to efficiently find the correct insertion position while maintaining the complete binary tree property!

Input & Output

example_1.py — Basic Usage

$ Input: CBTInserter cbt = new CBTInserter([1,2]); cbt.insert(3); cbt.insert(4); cbt.get_root();

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

💡 Note: First insert(3) attaches to node 2 (left child), returning 2. Second insert(4) attaches to node 2 (right child), returning 1 (next available parent). Final tree: 1 at root, with children 2,3 and 2 having children 4.

example_2.py — Larger Tree

$ Input: CBTInserter cbt = new CBTInserter([1,2,3,4,5,6]); cbt.insert(7); cbt.insert(8);

› Output: 3, 4

💡 Note: Tree starts complete to level 2: [1,2,3,4,5,6]. Insert(7) goes to node 3's left child, returning 3. Insert(8) goes to node 4's left child, returning 4. Maintains complete binary tree property.

example_3.py — Single Node

$ Input: CBTInserter cbt = new CBTInserter([1]); cbt.insert(2); cbt.get_root();

› Output: 1, [1,2]

💡 Note: Starting with single node 1, insert(2) adds as left child of 1, returning 1. Tree becomes [1,2] - still complete.

Constraints

The number of nodes in the tree is in the range [1, 1000]
Node values are in the range [0, 5000]
At most 10⁴ calls will be made to insert and get_root

Visualization

Tap to expand

Understanding the Visualization

Smart Ushering System

Instead of searching the entire theater each time, we keep a list of 'incomplete rows' that can still seat people

Instant Seating

When someone arrives, we immediately direct them to the first incomplete row without any searching

Dynamic Updates

When a row becomes full, we remove it from our list and add any new rows that can accept visitors

Key Takeaway

🎯 Key Insight: By maintaining a queue of incomplete nodes, we achieve O(1) insertion time while perfectly preserving the complete binary tree structure!

Asked in

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

The optimal solution uses a queue-based approach to maintain O(1) insertion time. During initialization, we build a queue of all incomplete nodes (nodes with available child slots). For each insertion, we simply use the front node from this queue, ensuring the leftmost available position. This maintains the complete binary tree property while achieving maximum efficiency.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Level Order Search)	O(n) per insert	O(w) where w is maximum width	Search entire tree level by level to find insertion point
Queue-Based Optimization (Optimal)	O(1) per insert, O(n) init	O(√n)	Maintain queue of nodes with available children for O(1) insertion

Brute Force (Level Order Search) — Algorithm Steps

Start level-order traversal from root
Check each node to see if it has available children
Insert at first available position
Return the parent's value

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Search

Begin level order traversal from root

Check Nodes

Examine each node for available child slots

Found Spot

Insert at first available position

Code -

solution.c — C

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

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

struct CBTInserter {
    struct TreeNode* root;
};

struct CBTInserter* cBTInserterCreate(struct TreeNode* root) {
    struct CBTInserter* obj = (struct CBTInserter*)malloc(sizeof(struct CBTInserter));
    obj->root = root;
    return obj;
}

int cBTInserterInsert(struct CBTInserter* obj, int val) {
    struct TreeNode* newNode = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    newNode->val = val;
    newNode->left = NULL;
    newNode->right = NULL;
    
    struct TreeNode* queue[10000];
    int front = 0, rear = 0;
    queue[rear++] = obj->root;
    
    while (front < rear) {
        struct TreeNode* node = queue[front++];
        
        if (!node->left) {
            node->left = newNode;
            return node->val;
        } else if (!node->right) {
            node->right = newNode;
            return node->val;
        } else {
            queue[rear++] = node->left;
            queue[rear++] = node->right;
        }
    }
    
    return -1;
}

struct TreeNode* cBTInserterGet_root(struct CBTInserter* obj) {
    return obj->root;
}

void cBTInserterFree(struct CBTInserter* obj) {
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(n) per insert

Must traverse the entire tree to find the insertion point for each new node

✓ Linear Growth

Space Complexity

O(w) where w is maximum width

Queue for level-order traversal can contain up to one full level of nodes

✓ Linear Space

28.7K Views

Medium Frequency

~18 min Avg. Time

956 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

Brute Force (Level Order Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler