Check Completeness of a Binary Tree - Practice Coding Problems

Check Completeness of a Binary Tree - Problem

Complete Binary Tree Verification

You're given the root of a binary tree and need to determine if it represents a complete binary tree.

A complete binary tree is a special type of binary tree where:
• Every level is completely filled, except possibly the last level
• All nodes in the last level are positioned as far left as possible
• The last level can have between 1 and 2^h nodes (where h is the height)

Goal: Return true if the tree is complete, false otherwise.

Example: A tree with nodes [1,2,3,4,5,6] is complete, but [1,2,3,4,null,6] is not (gap in last level).

Input & Output

example_1.py — Complete Binary Tree

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

› Output: true

💡 Note: This tree is complete because all levels are filled from left to right. Level 0 has node 1, level 1 has nodes 2,3, and level 2 has nodes 4,5,6 positioned leftmost.

example_2.py — Incomplete Binary Tree

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

› Output: false

💡 Note: This tree is not complete because there's a gap in the last level. Node 6 is missing, but node 7 exists, violating the 'leftmost' rule for complete binary trees.

example_3.py — Single Node Tree

$ Input: [1]

› Output: true

💡 Note: A single node tree is always complete by definition, as there are no gaps or violations of the completeness property.

Constraints

The number of nodes in the tree is in the range [0, 100]
1 ≤ Node.val ≤ 1000
Note: Tree is given in level-order array format where null represents missing nodes

Visualization

Tap to expand

null,7]✗ Found 7 after null - NOT COMPLETE!🚀 Key InsightOnce NULL appears in BFS, all following must be NULL

Understanding the Visualization

Complete Tree Pattern

All levels filled left-to-right, no gaps in last level

Incomplete Tree Pattern

Gap exists in last level with nodes to the right of the gap

BFS Detection Method

Level-order traversal catches violations immediately

Key Takeaway

🎯 Key Insight: BFS level-order traversal naturally detects completeness violations - once we see a null node, all subsequent nodes in the queue must also be null for the tree to be complete.

Asked in

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

The optimal solution uses BFS level-order traversal with a key insight: in a complete binary tree, once we encounter a null node during traversal, all subsequent nodes must also be null. We maintain a foundNull flag and return false if we see a non-null node after setting this flag. This achieves O(n) time complexity with a single pass through the tree.

Common Approaches

Approach	Time	Space	Notes
✓ BFS Level-Order Traversal (Optimal)	O(n)	O(w)	Use BFS to detect the first null node, then verify all subsequent nodes are null
Recursive Level Validation	O(n²)	O(h)	Check each level individually for completeness using recursive tree traversal

BFS Level-Order Traversal (Optimal) — Algorithm Steps

Initialize a queue with the root node for BFS traversal
Use a boolean flag 'foundNull' to track if we've seen a null node
For each node, add both left and right children (including nulls) to queue
If we encounter a null node, set foundNull = true
If foundNull is true and we see a non-null node, return false
Continue until queue is empty - if no violations found, tree is complete

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize BFS

Start with root in queue, foundNull = false

Process Each Node

Add both children to queue, track null encounters

Detect Violation

If non-null appears after null, return false

Complete Success

If no violations found, tree is complete

Code -

solution.c — C

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

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

struct Queue {
    struct TreeNode **data;
    int front, rear, capacity;
};

struct Queue* createQueue(int capacity) {
    struct Queue* queue = (struct Queue*)malloc(sizeof(struct Queue));
    queue->capacity = capacity;
    queue->front = 0;
    queue->rear = -1;
    queue->data = (struct TreeNode**)malloc(capacity * sizeof(struct TreeNode*));
    return queue;
}

void enqueue(struct Queue* queue, struct TreeNode* node) {
    queue->rear = (queue->rear + 1) % queue->capacity;
    queue->data[queue->rear] = node;
}

struct TreeNode* dequeue(struct Queue* queue) {
    struct TreeNode* node = queue->data[queue->front];
    queue->front = (queue->front + 1) % queue->capacity;
    return node;
}

bool isEmpty(struct Queue* queue) {
    return (queue->rear + 1) % queue->capacity == queue->front;
}

bool isCompleteTree(struct TreeNode* root) {
    if (!root) return true;
    
    struct Queue* queue = createQueue(10000);
    enqueue(queue, root);
    bool foundNull = false;
    
    while (!isEmpty(queue)) {
        struct TreeNode* node = dequeue(queue);
        
        if (!node) {
            foundNull = true;
        } else {
            // If we found null before and now see non-null
            if (foundNull) {
                free(queue->data);
                free(queue);
                return false;
            }
            
            // Add children (including potential nulls)
            enqueue(queue, node->left);
            enqueue(queue, node->right);
        }
    }
    
    free(queue->data);
    free(queue);
    return true;
}

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

int main() {
    // For demonstration - in practice would parse input
    struct TreeNode* root = createNode(1);
    root->left = createNode(2);
    root->right = createNode(3);
    root->left->left = createNode(4);
    root->left->right = createNode(5);
    root->right->left = createNode(6);
    
    printf("%s\n", isCompleteTree(root) ? "true" : "false");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each node exactly once during the BFS traversal

✓ Linear Growth

Space Complexity

O(w)

Queue stores at most the width of the tree (maximum nodes at any level), which is O(n) in worst case

✓ Linear Space

73.2K 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 (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler