Complete Binary Tree Inserter - Practice Coding Problems

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
✓ 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)	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) — Algorithm Steps

Initialize: Build queue of incomplete nodes via level-order traversal
Insert: Take front node from queue, add child
Update: If node becomes full, remove from queue; add new children if they can accept kids
Return parent's value

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Queue

Build queue of nodes that can accept children

Quick Insert

Use front of queue for O(1) insertion

Update Queue

Maintain queue as nodes become complete

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 TreeNode** incomplete;
    int front, rear, capacity;
};

struct CBTInserter* cBTInserterCreate(struct TreeNode* root) {
    struct CBTInserter* obj = (struct CBTInserter*)malloc(sizeof(struct CBTInserter));
    obj->root = root;
    obj->capacity = 10000;
    obj->incomplete = (struct TreeNode**)malloc(obj->capacity * sizeof(struct TreeNode*));
    obj->front = 0;
    obj->rear = 0;
    
    // Build incomplete queue
    struct TreeNode* queue[10000];
    int qfront = 0, qrear = 0;
    queue[qrear++] = root;
    
    while (qfront < qrear) {
        struct TreeNode* node = queue[qfront++];
        
        if (!node->left || !node->right) {
            obj->incomplete[obj->rear++] = node;
        }
        
        if (node->left) queue[qrear++] = node->left;
        if (node->right) queue[qrear++] = node->right;
    }
    
    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* parent = obj->incomplete[obj->front];
    
    if (!parent->left) {
        parent->left = newNode;
    } else {
        parent->right = newNode;
        obj->front++;
    }
    
    obj->incomplete[obj->rear++] = newNode;
    return parent->val;
}

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

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

Time & Space Complexity

Time Complexity

⏱️

O(1) per insert, O(n) init

Initialization scans all nodes once. Each insertion is constant time using the queue

✓ Linear Growth

Space Complexity

O(√n)

Queue stores incomplete nodes, which is roughly the bottom level of the tree

⚡ Linearithmic 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

Queue-Based Optimization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler