Count Complete Tree Nodes - Practice Coding Problems

Count Complete Tree Nodes - Problem

Complete Binary Tree Node Counter

You're given the root of a complete binary tree and need to count all nodes efficiently. A complete binary tree is a special type where:

• All levels are completely filled except possibly the last level
• The last level is filled from left to right
• At level h, there can be between 1 and 2^h nodes

The challenge? Design an algorithm that runs in less than O(n) time - faster than visiting every node! This problem tests your ability to exploit the special properties of complete binary trees.

Input: Root of a complete binary tree
Output: Total number of nodes in the tree

Input & Output

example_1.py — Complete Binary Tree

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

› Output: 6

💡 Note: The tree has 6 nodes total. All levels are completely filled except the last level, which has nodes 4, 5, 6 filled from left to right.

example_2.py — Perfect Binary Tree

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

› Output: 7

💡 Note: This is a perfect binary tree where all levels are completely filled. The optimal algorithm can use the formula 2^h - 1 = 2^3 - 1 = 7.

example_3.py — Single Node

$ Input: root = [1]

› Output: 1

💡 Note: Edge case with only one node - both simple traversal and optimized approaches return 1.

Visualization

Tap to expand

Understanding the Visualization

Identify Structure

Complete binary tree fills levels left to right, top to bottom

Height Comparison

Compare leftmost and rightmost path lengths to detect perfect subtrees

Apply Formula

Perfect subtrees: use 2^h - 1. Incomplete subtrees: recurse

Combine Results

Sum up counts from all subtrees efficiently

Key Takeaway

🎯 Key Insight: Complete binary trees allow us to identify perfect subtrees by comparing heights, enabling mathematical counting instead of node-by-node traversal for significant time savings.

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit every single node in the tree exactly once

✓ Linear Growth

Space Complexity

O(h)

Recursive call stack depth equals tree height h, which is log n for complete trees

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 5 × 10⁴]
0 ≤ Node.val ≤ 5 × 10⁴
The tree is guaranteed to be complete
Design an algorithm that runs in less than O(n) time complexity

Asked in

G Google 42 a Amazon 35 f Facebook 28 ⊞ Microsoft 24 Apple 18

The optimal solution leverages the complete binary tree property to achieve O(log²n) time complexity. By comparing left and right heights, we can identify perfect subtrees and use the mathematical formula 2^h - 1 instead of counting nodes individually. This approach makes at most log n recursive calls, each doing O(log n) height calculations, resulting in the required sub-linear time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Simple Tree Traversal	O(n)	O(h)	Visit every node and count them one by one
Binary Search on Complete Tree (Optimal)	O(log²n)	O(log n)	Exploit complete tree properties using binary search to achieve O(log²n) time

Simple Tree Traversal — Algorithm Steps

Start from the root node
Recursively visit left and right subtrees
Count each node as we visit it
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Root

Begin counting from the root node (count = 1)

Visit Left Subtree

Recursively count all nodes in the left subtree

Visit Right Subtree

Recursively count all nodes in the right subtree

Combine Results

Add 1 (root) + left count + right count

Code -

solution.c — C

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

// Definition for a binary tree node
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

int countNodes(struct TreeNode* root) {
    if (!root) return 0;
    return 1 + countNodes(root->left) + countNodes(root->right);
}

// Alternative iterative approach using array as stack
int countNodesIterative(struct TreeNode* root) {
    if (!root) return 0;
    
    struct TreeNode* stack[100000];
    int top = 0;
    stack[top++] = root;
    int count = 0;
    
    while (top > 0) {
        struct TreeNode* node = stack[--top];
        count++;
        if (node->right) stack[top++] = node->right;
        if (node->left) stack[top++] = node->left;
    }
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit every single node in the tree exactly once

✓ Linear Growth

Space Complexity

O(h)

Recursive call stack depth equals tree height h, which is log n for complete trees

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 5 × 10⁴]
0 ≤ Node.val ≤ 5 × 10⁴
The tree is guaranteed to be complete
Design an algorithm that runs in less than O(n) time complexity

89.2K Views

Medium-High Frequency

~15 min Avg. Time

2.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

Simple Tree Traversal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler