Count Leaf Nodes - Problem

Given a binary tree, count the number of leaf nodes and internal nodes separately. Also, calculate the diameter of the tree (the longest path between any two nodes).

A leaf node is a node with no children. An internal node is a node with at least one child. The diameter is the number of edges in the longest path between any two nodes in the tree.

Return an array [leafCount, internalCount, diameter].

Input & Output

Example 1 — Basic Tree

$ Input: root = [3,9,20,null,null,15,7]

› Output: [3,2,3]

💡 Note: Leaf nodes: 9, 15, 7 (count=3). Internal nodes: 3, 20 (count=2). Diameter: longest path 9→3→20→15 has 3 edges.

Example 2 — Single Node

$ Input: root = [1]

› Output: [1,0,0]

💡 Note: Only root node exists: 1 leaf node, 0 internal nodes, diameter is 0 (no edges).

Example 3 — Linear Tree

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

› Output: [1,2,2]

💡 Note: Leaf: node 3. Internals: nodes 1, 2. Diameter: path 3→2→1 has 2 edges.

Constraints

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

Visualization

Tap to expand

Asked in

A Amazon 15 M Microsoft 12 G Google 8 🍎 Apple 6

The key insight is to use a single DFS traversal that calculates all three metrics (leaf count, internal count, and diameter) simultaneously by processing child information bottom-up. The optimal approach visits each node once, determining its type and contributing to the diameter calculation. Time: O(n), Space: O(h) where h is tree height.

Common Approaches

✓ Multiple DFS Traversals

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

Perform three separate DFS traversals: one to count leaf nodes, one to count internal nodes, and one to calculate the diameter by finding the maximum path through each node.

Single DFS with Combined Logic

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

Perform a single DFS traversal that calculates leaf count, internal count, and diameter in one pass by processing information bottom-up from child nodes.

Multiple DFS Traversals — Algorithm Steps

First DFS: traverse all nodes and count those with no children (leaves)
Second DFS: traverse all nodes and count those with at least one child (internals)
Third DFS: for diameter, calculate max path through each node and track global maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Leaves

First DFS finds nodes with no children

Count Internals

Second DFS finds nodes with at least one child

Calculate Diameter

Third DFS finds longest path between any two nodes

Code -

solution.c — C

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

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

struct TreeNode* createNode(int val) {
    struct TreeNode* node = malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

int countLeaves(struct TreeNode* node) {
    if (!node) return 0;
    if (!node->left && !node->right) return 1;
    return countLeaves(node->left) + countLeaves(node->right);
}

int countInternals(struct TreeNode* node) {
    if (!node) return 0;
    if (!node->left && !node->right) return 0;
    return 1 + countInternals(node->left) + countInternals(node->right);
}

void calculateDiameter(struct TreeNode* node, int* height, int* diameter) {
    if (!node) {
        *height = 0;
        *diameter = 0;
        return;
    }
    
    int leftHeight = 0, rightHeight = 0;
    int leftDiameter = 0, rightDiameter = 0;
    
    calculateDiameter(node->left, &leftHeight, &leftDiameter);
    calculateDiameter(node->right, &rightHeight, &rightDiameter);
    
    *height = 1 + (leftHeight > rightHeight ? leftHeight : rightHeight);
    int throughRoot = leftHeight + rightHeight;
    *diameter = leftDiameter > rightDiameter ? leftDiameter : rightDiameter;
    if (throughRoot > *diameter) *diameter = throughRoot;
}

void solution(struct TreeNode* root, int* result) {
    if (!root) {
        result[0] = result[1] = result[2] = 0;
        return;
    }
    
    result[0] = countLeaves(root);
    result[1] = countInternals(root);
    
    int height;
    calculateDiameter(root, &height, &result[2]);
}

int main() {
    // For simplicity, assume input [3,9,20,null,null,15,7]
    struct TreeNode* root = createNode(3);
    root->left = createNode(9);
    root->right = createNode(20);
    root->right->left = createNode(15);
    root->right->right = createNode(7);
    
    int result[3];
    solution(root, result);
    
    printf("[%d,%d,%d]\n", result[0], result[1], result[2]);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Three separate O(n) traversals, still linear overall

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height for DFS calls

✓ Linear Space

23.5K Views

Medium Frequency

~15 min Avg. Time

847 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

Count Leaf Nodes - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Multiple DFS Traversals — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler