Check Completeness of a Binary Tree

Check Completeness of a Binary Tree - Problem

Given the root of a binary tree, determine if it is a complete binary tree.

In a complete binary tree, every level, except possibly the last, is completely filled, and all nodes in the last level are as far left as possible. It can have between 1 and 2^h nodes inclusive at the last level h.

Input & Output

Example 1 — Complete Binary Tree

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

› Output: true

💡 Note: All levels are filled completely, and the last level nodes (4,5,6) are as far left as possible. This satisfies the definition of a complete binary tree.

Example 2 — Incomplete Binary Tree

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

› Output: false

💡 Note: Node 7 exists but node 6 is missing. In a complete binary tree, all nodes in the last level must be as far left as possible, so there should be no gaps.

Example 3 — Single Node

$ Input: root = [1]

› Output: true

💡 Note: A single node tree is always complete - it has only one level with one node, which satisfies all completeness conditions.

Constraints

The number of nodes in the tree is in the range [1, 100]
1 ≤ Node.val ≤ 1000

Visualization

Tap to expand

Asked in

F Facebook 15 A Amazon 12 M Microsoft 8

The key insight is that in a complete binary tree, once we encounter a null node during level-order traversal, all subsequent nodes must also be null. The optimal BFS approach gives us Time: O(n), Space: O(w) where w is the maximum width of the tree.

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Sliding Window

⏱️ Time: N/A Space: N/A

BFS with Null Detection

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

Perform level-order traversal using a queue. In a complete binary tree, once we encounter the first null node, all subsequent nodes in the traversal should be null. If we find a non-null node after a null, the tree is not complete.

Level-by-Level Counting

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

Calculate the depth of the tree, then for each level check if it has the expected number of nodes. For all levels except the last, count must equal 2^level. For the last level, nodes must be left-aligned.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static int values[10000];
static bool isNull[10000];
static int queue[10000];

int parseTree(char* input) {
    int len = strlen(input);
    if (len <= 2) return 0; // empty array []
    
    int count = 0;
    int i = 1; // skip opening bracket
    
    while (i < len - 1) { // skip closing bracket
        // Skip whitespace and commas
        while (i < len && (input[i] == ' ' || input[i] == ',')) i++;
        if (i >= len - 1) break;
        
        // Check for null
        if (i + 3 < len && strncmp(&input[i], "null", 4) == 0) {
            isNull[count] = true;
            values[count] = 0;
            i += 4;
        } else {
            // Parse number
            isNull[count] = false;
            int num = 0;
            bool negative = false;
            if (input[i] == '-') {
                negative = true;
                i++;
            }
            while (i < len && input[i] >= '0' && input[i] <= '9') {
                num = num * 10 + (input[i] - '0');
                i++;
            }
            values[count] = negative ? -num : num;
        }
        count++;
    }
    
    return count;
}

bool isCompleteTree(int size) {
    if (size == 0) return true;
    
    int front = 0, rear = 0;
    queue[rear++] = 0;
    bool foundNull = false;
    
    while (front < rear) {
        int idx = queue[front++];
        
        if (idx >= size || isNull[idx]) {
            foundNull = true;
        } else {
            if (foundNull) return false; // found non-null after null
            
            int leftChild = 2 * idx + 1;
            int rightChild = 2 * idx + 2;
            
            if (leftChild < size) {
                queue[rear++] = leftChild;
            }
            if (rightChild < size) {
                queue[rear++] = rightChild;
            }
        }
    }
    
    return true;
}

int main() {
    char input[100000];
    fgets(input, sizeof(input), stdin);
    input[strcspn(input, "\n")] = 0;
    
    int size = parseTree(input);
    bool result = isCompleteTree(size);
    
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

89.2K Views

Medium Frequency

~15 min Avg. Time

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