A node is a leaf node if both left and right child nodes of it are NULL.
Here is an algorithm to get the leaf node count.
getLeafCount(node)
1) If node is NULL then return 0.
2) Else If left and right child nodes are NULL return 1.
3) Else recursively calculate leaf count of the tree using below formula.
Leaf count of a tree = Leaf count of left subtree +
Leaf count of right subtree
Leaf count for the above tree is 3.
Algorithm:
Step 1: Start
Step 2: Create a function named “getLeafCount”of int return type that take node as input parameter.
Step 3: Set the conditions:
a. If the node is NULL, return 0.
b. If the node has no left or right child, return 1.
c. Recursively call “getLeafCount” on the left and right child nodes if the node has left or right children, and then return the total of the results.
Step 4: End
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
struct node
{
int data;
struct node* left;
struct node* right;
};
unsigned int getLeafCount(struct node* node)
{
if(node == NULL)
return 0;
if(node->left == NULL && node->right == NULL)
return 1;
else
return getLeafCount(node->left)+
getLeafCount(node->right);
}
struct node* newNode(int data)
{
struct node* node = (struct node*)
malloc(sizeof(struct node));
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}
int main()
{
struct node *root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
cout << "Leaf count of the tree is : "<<
getLeafCount(root) << endl;
return 0;
}
|
C
#include <stdio.h>
#include <stdlib.h>
struct node
{
int data;
struct node* left;
struct node* right;
};
unsigned int getLeafCount(struct node* node)
{
if(node == NULL)
return 0;
if(node->left == NULL && node->right==NULL)
return 1;
else
return getLeafCount(node->left)+
getLeafCount(node->right);
}
struct node* newNode(int data)
{
struct node* node = (struct node*)
malloc(sizeof(struct node));
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}
int main()
{
struct node *root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
printf("Leaf count of the tree is %d", getLeafCount(root));
getchar();
return 0;
}
|
Java
class Node
{
int data;
Node left, right;
public Node(int item)
{
data = item;
left = right = null;
}
}
public class BinaryTree
{
Node root;
int getLeafCount()
{
return getLeafCount(root);
}
int getLeafCount(Node node)
{
if (node == null)
return 0;
if (node.left == null && node.right == null)
return 1;
else
return getLeafCount(node.left) + getLeafCount(node.right);
}
public static void main(String args[])
{
BinaryTree tree = new BinaryTree();
tree.root = new Node(1);
tree.root.left = new Node(2);
tree.root.right = new Node(3);
tree.root.left.left = new Node(4);
tree.root.left.right = new Node(5);
System.out.println("The leaf count of binary tree is : "
+ tree.getLeafCount());
}
}
|
Python3
class Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def getLeafCount(node):
if node is None:
return 0
if(node.left is None and node.right is None):
return 1
else:
return getLeafCount(node.left) + getLeafCount(node.right)
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)
print ("Leaf count of the tree is %d" %(getLeafCount(root)))
|
C#
using System;
public class Node
{
public int data;
public Node left, right;
public Node(int item)
{
data = item;
left = right = null;
}
}
public class BinaryTree
{
public Node root;
public virtual int LeafCount
{
get
{
return getLeafCount(root);
}
}
public virtual int getLeafCount(Node node)
{
if (node == null)
{
return 0;
}
if (node.left == null && node.right == null)
{
return 1;
}
else
{
return getLeafCount(node.left) + getLeafCount(node.right);
}
}
public static void Main(string[] args)
{
BinaryTree tree = new BinaryTree();
tree.root = new Node(1);
tree.root.left = new Node(2);
tree.root.right = new Node(3);
tree.root.left.left = new Node(4);
tree.root.left.right = new Node(5);
Console.WriteLine("The leaf count of binary tree is : " + tree.LeafCount);
}
}
|
Javascript
<script>
class node
{
constructor(data) {
this.left = null;
this.right = null;
this.data = data;
}
}
function getLeafCount(node)
{
if(node == null)
return 0;
if(node.left == null && node.right == null)
return 1;
else
return getLeafCount(node.left)+
getLeafCount(node.right);
}
function newNode(data)
{
let Node = new node(data);
return(Node);
}
let root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.left = newNode(4);
root.left.right = newNode(5);
document.write("The leaf count of binary tree is : " + getLeafCount(root));
</script>
|
OutputLeaf count of the tree is : 3
Time & Space Complexities: Since this program is similar to traversal of tree, time and space complexities will be same as Tree traversal (Please see our Tree Traversal post for details)
Another Approach(Iterative):
The given problem can be solved by using the Level Order Traversal(https://www.geeksforgeeks.org/level-order-tree-traversal/). Follow the steps below to solve the problem:
1) Create a queue(q) and initialize count variable with 0, and store the nodes in q along wise level order and iterate for next level.
2) Perform level order traversal and check if current node is a leaf node(don’t have right and left child) then increment the count variable.
3) After completing the above steps, return count variable.
Below is the implementation of above approach:
C++
#include <bits/stdc++.h>
using namespace std;
struct Node{
int data;
struct Node* left;
struct Node* right;
};
Node* newNode(int data){
Node *new_node = new Node();
new_node->data = data;
new_node->left = NULL;
new_node->right = NULL;
return new_node;
}
int getLeafCount(Node* root){
queue<Node*> q;
q.push(root);
int count = 0;
while(!q.empty()){
Node* temp = q.front();
q.pop();
if(temp->left == NULL && temp->right == NULL)
count++;
if(temp->left) q.push(temp->left);
if(temp->right) q.push(temp->right);
}
return count;
}
int main(){
struct Node *root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
cout << "Leaf count of the tree is : "<< getLeafCount(root) << endl;
return 0;
}
|
Java
import java.util.LinkedList;
import java.util.Queue;
class Node{
int data;
Node left, right;
public Node(int item){
data = item;
left = null;
right = null;
}
}
class BinaryTree{
static Node newNode(int data){
return new Node(data);
}
static int getLeafCount(Node root){
Queue<Node> q = new LinkedList<Node>();
q.add(root);
int count = 0;
while(!q.isEmpty()){
Node temp = q.poll();
if(temp.left == null && temp.right == null) count++;
if(temp.left != null) q.add(temp.left);
if(temp.right != null) q.add(temp.right);
}
return count;
}
public static void main(String args[]){
Node root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.left = newNode(4);
root.left.right = newNode(5);
System.out.println("Leaf count of the tree is : " + getLeafCount(root));
}
}
|
Python
class Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def newNode(data):
return Node(data)
def getLeafCount(root):
q = []
q.append(root)
count = 0
while(len(q) > 0):
temp = q.pop(0)
if(temp.left is None and temp.right is None):
count += 1
if(temp.left is not None):
q.append(temp.left)
if(temp.right is not None):
q.append(temp.right)
return count
root = newNode(1)
root.left = newNode(2)
root.right = newNode(3)
root.left.left = newNode(4)
root.left.right = newNode(5)
print("Leaf count of the tree is : ")
print(getLeafCount(root))
|
C#
using System;
using System.Collections.Generic;
public class Node{
public int data;
public Node left, right;
public Node(int data){
this.data = data;
this.left = null;
this.right = null;
}
}
public class BinaryTree{
static Node newNode(int data){
return new Node(data);
}
static int getLeafCount(Node root){
Queue<Node> q = new Queue<Node>();
q.Enqueue(root);
int count = 0;
while(q.Count > 0){
Node temp = q.Dequeue();
if(temp.left == null && temp.right == null) count++;
if(temp.left != null) q.Enqueue(temp.left);
if(temp.right != null) q.Enqueue(temp.right);
}
return count;
}
public static void Main(){
Node root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.left = newNode(4);
root.left.right = newNode(5);
Console.WriteLine("Leaf Count of the tree is : " + getLeafCount(root));
}
}
|
Javascript
class Node{
constructor(data){
this.data = data;
this.left = null;
this.right = null;
}
}
function newNode(data){
return new Node(data);
}
function getLeafCount(root){
let q = [];
q.push(root);
let count = 0;
while(q.length > 0){
let temp = q.shift();
if(temp.left == null && temp.right == null) count++;
if(temp.left) q.push(temp.left);
if(temp.right) q.push(temp.right);
}
return count;
}
let root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.left = newNode(4);
root.left.right = newNode(5);
console.log("Leaf count of the tree is : " + getLeafCount(root));
|
OutputLeaf count of the tree is : 3
Time Complexity: O(N) where N is the number of nodes in binary tree.
Auxiliary Space: O(N) due to queue data structure.
Please write comments if you find any bug in the above programs/algorithms or other ways to solve the same problem.