Program to count leaf nodes in a binary tree

Last Updated : 26 Sep, 2024

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:

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

Input:

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

Table of Content

[Expected Approach - 1] Using Recursion - O(n) Time and O(n) Space

The idea is to determine the count of leaf nodes in a binary tree using a recursive approach. 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

Follow the steps below to solve the problem:

Create a function named countLeaves() of that takes node as an input parameter and return the count of leaf nodes.
Set the conditions:
- 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.

Below is the implementation of the above approach:

C++

// C++ code to count leaf nodes in a binary tree // using recursion #include <bits/stdc++.h> 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; }

// C code to count leaf nodes in a binary tree // using recursion #include <stdio.h> #include <stdlib.h>  struct Node {     int data;     struct Node *left, *right; };  // Function to count the leaf nodes in a binary tree int countLeaves(struct 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); }  struct Node* createNode(int val) {     struct Node* node        = (struct Node*)malloc(sizeof(struct Node));     node->data = val;     node->left = node->right = NULL;     return node; }  int main() {        // Representation of input binary tree     //        1     //       / \     //      2   3     //     / \     //    4   5     struct Node* root = createNode(1);     root->left = createNode(2);     root->right = createNode(3);     root->left->left = createNode(4);     root->left->right = createNode(5);      printf("%d\n", countLeaves(root));      return 0; }

Java

// Java code to count leaf nodes in a binary tree // using recursion 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

# Python code to count leaf nodes in a binary tree # using recursion 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# code to count leaf nodes in a binary tree // using recursion 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

// JavaScript code to count leaf nodes in a binary tree // using recursion 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

Time Complexity: O(n), where n is the number of nodes in the binary tree, as each node is visited once to count the leaf nodes.
Space Complexity: O(h), where h is the height of the tree, due to the recursive call stack used for traversal.

[Expected Approach - 2] Iterative Approach - O(n) Time and O(n) Space

The idea is to use level order traversal to efficiently count the leaf nodes in a binary tree. By initializing a queue, we can traverse the tree level by level, checking 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. Please refer to Iterative program to count leaf nodes in a Binary Tree for implementation.

Pairwise Swap leaf nodes in a binary tree

kartik

Improve

Article Tags :

Practice Tags :

Program to count leaf nodes in a binary tree

[Expected Approach - 1] Using Recursion - O(n) Time and O(n) Space

[Expected Approach - 2] Iterative Approach - O(n) Time and O(n) Space

Similar Reads