Count Leaf Nodes in a Binary Tree

Last Updated : 10 May, 2026

Given a Binary Tree, the task is to count leaves in it. A node is a leaf node if both left and right child nodes of it are NULL. 

Example:

Input:

ex-3

Output: 3
Explanation: Three leaf nodes are 3, 4 and 5 as both of their left and right child is NULL.

Input:

ex-4

Output: 3
Explanation: Three leaf nodes are 4, 6 and 7 as both of their left and right child is NULL.

Table of Content

Using Recursion - O(n) Time and O(h) Space

If a node is NULL, the function returns 0. If both the left and right child nodes of the current node are NULL, it returns 1, indicating a leaf node. The count of leaf nodes from the left and right subtrees provide the total count leaf nodes.

Leaf count of a tree = Leaf count of left subtree + Leaf count of right subtree

  • If the node is NULL, return 0.
  • If the node has no left or right child, return 1.
  • Recursively call countLeaves() on the left and right child nodes if the node has left or right children, and then return the total of the results.
C++ 
#include <iostream>
using namespace std;

struct Node {
    int data;
    Node *left, *right;

    Node(int val) {
        data = val;
        left = right = nullptr;
    }
};

// Function to count the leaf nodes in a binary tree
int countLeaves(Node* root) {
  
    // If the root is null, return 0
    if (root == nullptr) {
        return 0;
    }
    
    // If the node has no left or right child,
    // it is a leaf node
    if (root->left == nullptr && root->right == nullptr) {
        return 1;
    }
    
    // Recursively count leaf nodes in left 
    // and right subtrees
    return countLeaves(root->left) + countLeaves(root->right);
}

int main() {
  
    // Representation of input binary tree
    //        1
    //       / \
    //      2   3
    //     / \
    //    4   5
    Node* root = new Node(1);
    root->left = new Node(2);
    root->right = new Node(3);
    root->left->left = new Node(4);
    root->left->right = new Node(5);

    cout << countLeaves(root) << "\n";  

    return 0;
}
Java 
class Node {
    int data;
    Node left, right;

    Node(int val) {
        data = val;
        left = right = null;
    }
}

class GfG {

    // Function to count the leaf nodes in a binary tree
    static int countLeaves(Node root) {
      
        // If root is NULL, return 0
        if (root == null) {
            return 0;
        }

        // If the node has no left or right child, 
        // it is a leaf
        if (root.left == null && root.right == null) {
            return 1;
        }

        // Recursively count the leaves in the 
        // left and right subtrees
        return countLeaves(root.left) 
                         + countLeaves(root.right);
    }

    public static void main(String[] args) {
      
        // Representation of input binary tree
        //        1
        //       / \
        //      2   3
        //     / \
        //    4   5
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);

        System.out.println(countLeaves(root));
    }
}
Python 
class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

def countLeaves(root):
  
    # If root is None, return 0
    if root is None:
        return 0

    # If the node has no left or right child, it is a leaf
    if root.left is None and root.right is None:
        return 1

    # Recursively count the leaves in the left and right subtrees
    return countLeaves(root.left) + countLeaves(root.right)

if __name__ == "__main__":
  
    # Representation of input binary tree
    #        1
    #       / \
    #      2   3
    #     / \
    #    4   5
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.left.left = Node(4)
    root.left.right = Node(5)

    print(countLeaves(root))
C# 
using System;

class Node {
    public int data;
    public Node left, right;

    public Node(int val) {
        data = val;
        left = right = null;
    }
}

class GfG {

    static int countLeaves(Node root) {
      
        // If the root is null, return 0
        if (root == null) {
            return 0;
        }

        // If the node has no left or right child,
        // it is a leaf
        if (root.left == null && root.right == null) {
            return 1;
        }

        // Recursively count the leaves in the left 
        // and right subtrees
        return countLeaves(root.left) 
                             + countLeaves(root.right);
    }

    static void Main(string[] args) {
      
        // Representation of input binary tree
        //        1
        //       / \
        //      2   3
        //     / \
        //    4   5
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);

        Console.WriteLine(countLeaves(root));
    }
}
JavaScript 
class Node {
    constructor(data) {
        this.data = data;
        this.left = null;
        this.right = null;
    }
}

function countLeaves(root) {

    // If the root is null, return 0
    if (root === null) {
        return 0;
    }

    // If the node has no left or right child,
    // it is a leaf
    if (root.left === null && root.right === null) {
        return 1;
    }

    // Recursively count the leaves in the left 
    // and right subtrees
    return countLeaves(root.left) + countLeaves(root.right);
}

// Representation of input binary tree
//        1
//       / \
//      2   3
//     / \
//    4   5
let root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);

console.log(countLeaves(root));

Output
3

Iterative Approach - O(n) Time and O(n) Space

The idea is to use the queue based level order traversal to efficiently count the leaf nodes in a binary tree. We check each node as it is dequeued from queue. For every node, we check if it has no left or right children, indicating that it is a leaf node, and increment our count accordingly.

  • Create a queue to traverse in level order manner and a variable count to keep track of the number of leaf nodes. Start by enqueuing the root node.
  • While the queue is not empty, proceed with the traversal.
    • Dequeue the front node from the queue and check its children.
    • If both the left and right children of the current node are NULL, increment the count variable by 1, indicating that a leaf node has been found.
    • If the current node has a left child, enqueue it into the queue. Similarly, if it has a right child, enqueue that child also.
  • Finally, return the count of leaf nodes found during the traversal.
C++ 
#include <iostream>
using namespace std;

struct Node {
    int data;
    Node *left, *right;

    Node(int val) {
        data = val;
        left = right = nullptr;
    }
};

// Function to count the leaf nodes in a binary tree
int countLeaves(Node* root) {
  
    // If the root is null, return 0
    if (root == nullptr) {
        return 0;
    }

    // Initialize a queue for level order traversal
    queue<Node*> q;
    q.push(root);

    int count = 0;

    // Traverse the tree using level order traversal
    while (!q.empty()) {
        Node* curr = q.front();
        q.pop();

        // Check if the current node is a leaf node
        if (curr->left == nullptr && curr->right == nullptr) {
            count++;
        }

        // Enqueue left and right children if they exist
        if (curr->left != nullptr) {
            q.push(curr->left);
        }
        if (curr->right != nullptr) {
            q.push(curr->right);
        }
    }

    return count;
}

int main() {
  
    // Representation of input binary tree
    //        1
    //       / \
    //      2   3
    //     / \
    //    4   5
    Node* root = new Node(1);
    root->left = new Node(2);
    root->right = new Node(3);
    root->left->left = new Node(4);
    root->left->right = new Node(5);

    cout << countLeaves(root) << "\n";

    return 0;
}
Java 
import java.util.LinkedList;
import java.util.Queue;

class Node {
    int data;
    Node left, right;

    Node(int val) {
        data = val;
        left = right = null;
    }
}

class GfG {

    // Function to count the leaf nodes in a binary tree
    static int countLeaves(Node root) {
      
        // If root is NULL, return 0
        if (root == null) {
            return 0;
        }

        // Initialize a queue for level order traversal
        Queue<Node> queue = new LinkedList<>();
        queue.add(root);
        
        int count = 0;

        // Traverse the tree using level order traversal
        while (!queue.isEmpty()) {
            Node curr = queue.poll();

            // Check if the current node is a leaf node
            if (curr.left == null && curr.right == null) {
                count++;
            }

            // Enqueue left and right children if they exist
            if (curr.left != null) {
                queue.add(curr.left);
            }
            if (curr.right != null) {
                queue.add(curr.right);
            }
        }

        return count;
    }

    public static void main(String[] args) {
      
        // Representation of input binary tree
        //        1
        //       / \
        //      2   3
        //     / \
        //    4   5
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);

        System.out.println(countLeaves(root));
    }
}
Python 
from collections import deque

class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

def countLeaves(root):
  
    # If root is None, return 0
    if root is None:
        return 0

    # Initialize a queue for level order traversal
    queue = deque([root])
    
    count = 0

    # Traverse the tree using level order traversal
    while queue:
        curr = queue.popleft()

        # Check if the current node is a leaf node
        if curr.left is None and curr.right is None:
            count += 1

        # Enqueue left and right children if they exist
        if curr.left is not None:
            queue.append(curr.left)
        if curr.right is not None:
            queue.append(curr.right)

    return count

if __name__ == "__main__":
  
    # Representation of input binary tree
    #        1
    #       / \
    #      2   3
    #     / \
    #    4   5
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.left.left = Node(4)
    root.left.right = Node(5)

    print(countLeaves(root))
C# 
using System;
using System.Collections.Generic;

class Node {
    public int data;
    public Node left, right;

    public Node(int val) {
        data = val;
        left = right = null;
    }
}

class GfG {

    static int CountLeaves(Node root) {
      
        // If the root is null, return 0
        if (root == null) {
            return 0;
        }

        // Initialize a queue for level order traversal
        Queue<Node> queue = new Queue<Node>();
        queue.Enqueue(root);
        
        // Variable to count leaf nodes
        int count = 0;

        // Traverse the tree using level order traversal
        while (queue.Count > 0) {
            Node curr = queue.Dequeue();

            // Check if the current node is a leaf node
            if (curr.left == null && curr.right == null) {
                count++;
            }

            // Enqueue left and right children if they exist
            if (curr.left != null) {
                queue.Enqueue(curr.left);
            }
            if (curr.right != null) {
                queue.Enqueue(curr.right);
            }
        }

        return count;
    }

    static void Main(string[] args) {
      
        // Representation of input binary tree
        //        1
        //       / \
        //      2   3
        //     / \
        //    4   5
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);

        Console.WriteLine(CountLeaves(root));
    }
}
JavaScript 
class Node {
    constructor(data) {
        this.data = data;
        this.left = null;
        this.right = null;
    }
}

function countLeaves(root) {

    // If the root is null, return 0
    if (root === null) {
        return 0;
    }

    // Initialize a queue for level order traversal
    const queue = [];
    queue.push(root);

    let count = 0;

    // Traverse the tree using level order traversal
    while (queue.length > 0) {
        const curr = queue.shift();

        // Check if the current node is a leaf node
        if (curr.left === null && curr.right === null) {
            count++;
        }

        // Enqueue left and right children if they exist
        if (curr.left !== null) {
            queue.push(curr.left);
        }
        if (curr.right !== null) {
            queue.push(curr.right);
        }
    }
    
    return count;
}

// Representation of input binary tree
//        1
//       / \
//      2   3
//     / \
//    4   5
let root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);

console.log(countLeaves(root));

Output
3
Comment
Article Tags:
Tree
DSA
Ola Cabs

Explore