Iterative program to count leaf nodes in a Binary Tree
Given a binary tree, count leaves in the tree without using recursion. A node is a leaf node if both left and right children of it are NULL.
Example Tree
Leaves count for the above tree is 3.
The idea is to use level order traversal. During traversal, if we find a node whose left and right children are NULL, we increment count.
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
struct Node
{
int data;
struct Node* left, *right;
};
unsigned int getLeafCount( struct Node* node)
{
if (!node)
return 0;
queue<Node *> q;
int count = 0;
q.push(node);
while (!q.empty())
{
struct Node *temp = q.front();
q.pop();
if (temp->left != NULL)
q.push(temp->left);
if (temp->right != NULL)
q.push(temp->right);
if (temp->left == NULL && temp->right == NULL)
count++;
}
return count;
}
struct Node* newNode( int data)
{
struct Node* node = new Node;
node->data = data;
node->left = 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 << getLeafCount(root);
return 0;
}
|
Java
import java.util.*;
class GFG
{
static class Node
{
int data;
Node left, right;
}
static int getLeafCount(Node node)
{
if (node == null )
{
return 0 ;
}
Queue<Node> q = new LinkedList<>();
int count = 0 ;
q.add(node);
while (!q.isEmpty())
{
Node temp = q.peek();
q.poll();
if (temp.left != null )
{
q.add(temp.left);
}
if (temp.right != null )
{
q.add(temp.right);
}
if (temp.left == null &&
temp.right == null )
{
count++;
}
}
return count;
}
static Node newNode( int data)
{
Node node = new Node();
node.data = data;
node.left = node.right = null ;
return (node);
}
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(getLeafCount(root));
}
}
}
|
Python3
from queue import Queue
class newNode:
def __init__( self , data):
self .data = data
self .left = self .right = None
def getLeafCount(node):
if ( not node):
return 0
q = Queue()
count = 0
q.put(node)
while ( not q.empty()):
temp = q.queue[ 0 ]
q.get()
if (temp.left ! = None ):
q.put(temp.left)
if (temp.right ! = None ):
q.put(temp.right)
if (temp.left = = None and
temp.right = = None ):
count + = 1
return count
if __name__ = = '__main__' :
root = newNode( 1 )
root.left = newNode( 2 )
root.right = newNode( 3 )
root.left.left = newNode( 4 )
root.left.right = newNode( 5 )
print (getLeafCount(root))
|
C#
using System;
using System.Collections.Generic;
class GFG
{
public class Node
{
public int data;
public Node left, right;
}
static int getLeafCount(Node node)
{
if (node == null )
{
return 0;
}
Queue<Node> q = new Queue<Node>();
int count = 0;
q.Enqueue(node);
while (q.Count!=0)
{
Node temp = q.Peek();
q.Dequeue();
if (temp.left != null )
{
q.Enqueue(temp.left);
}
if (temp.right != null )
{
q.Enqueue(temp.right);
}
if (temp.left == null &&
temp.right == null )
{
count++;
}
}
return count;
}
static Node newNode( int data)
{
Node node = new Node();
node.data = data;
node.left = node.right = null ;
return (node);
}
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);
Console.WriteLine(getLeafCount(root));
}
}
}
|
Javascript
<script>
class Node
{
constructor(data)
{
this .data=data;
this .left= this .right= null ;
}
}
function getLeafCount(node)
{
if (node == null )
{
return 0;
}
let q = [];
let count = 0;
q.push(node);
while (q.length!=0)
{
let temp = q.shift();
if (temp.left != null )
{
q.push(temp.left);
}
if (temp.right != null )
{
q.push(temp.right);
}
if (temp.left == null &&
temp.right == null )
{
count++;
}
}
return count;
}
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);
document.write(getLeafCount(root));
</script>
|
Time Complexity: O(n)
Auxiliary space: O(n)
Here is a recursive solution for the same problem:
The idea is simple we break the larger tree into smaller sub-trees and solve for them to get the final answer.
Below is the implementation of the above approach.
C++
#include <iostream>
using namespace std;
struct node
{
int data;
struct node* left;
struct node* right;
};
int countLeaves( struct node *node)
{
if (node == NULL)
{
return 0;
}
if (node->left == NULL && node->right == NULL)
{
return 1;
}
return countLeaves(node->left) + countLeaves(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<<countLeaves(root)<<endl;
}
|
Java
import java.util.LinkedList;
import java.util.Queue;
import java.io.*;
import java.util.*;
class GfG
{
static class Node
{
int data;
Node left, right;
}
static int countLeaves(Node node)
{
if (node == null )
return 0 ;
if (node.left == null &&
node.right == null )
return 1 ;
return countLeaves(node.left)
+ countLeaves(node.right);
}
static Node newNode( int data)
{
Node node = new Node();
node.data = data;
node.left = node.right = null ;
return (node);
}
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(countLeaves(root));
}
}
|
Python3
class Node:
def __init__( self ,x):
self .data = x
self .left = None
self .right = None
def countLeaves(node):
if (node = = None ):
return 0
if (node.left = = None and node.right = = None ):
return 1
return countLeaves(node.left) + countLeaves(node.right)
if __name__ = = '__main__' :
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;
public class Node
{
public int data;
public Node left, right;
public Node( int d)
{
data = d;
left = right = null ;
}
}
public class BinaryTree{
public static Node root;
static int countLeaves(Node node)
{
if (node == null )
{
return 0;
}
if (node.left == null &&
node.right == null )
{
return 1;
}
return countLeaves(node.left) +
countLeaves(node.right);
}
static public void Main()
{
BinaryTree.root = new Node(1);
BinaryTree.root.left = new Node(2);
BinaryTree.root.right = new Node(3);
BinaryTree.root.left.left = new Node(4);
BinaryTree.root.left.right = new Node(5);
Console.WriteLine(countLeaves(root));
}
}
|
Javascript
<script>
class Node
{
constructor(data)
{
this .data=data;
this .next = this .right = null ;
}
}
function countLeaves(node)
{
if (node == null )
return 0;
if (node.left == null &&
node.right == null )
return 1;
return countLeaves(node.left)
+ countLeaves(node.right);
}
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);
document.write(countLeaves(root));
</script>
|
Time complexity: O(n) where n is no of nodes in given Binary Tree
Auxiliary space: O(n)
This article is contributed by Mr. Somesh Awasthi.
Last Updated :
17 Jan, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...