Count full nodes in a Binary tree (Iterative and Recursive)
Last Updated :
19 Jul, 2022
Given A binary Tree, how do you count all the full nodes (Nodes which have both children as not NULL) without using recursion and with recursion? Note leaves should not be touched as they have both children as NULL.
Nodes 2 and 6 are full nodes has both child’s. So count of full nodes in the above tree is 2
Method: Iterative
The idea is to use level-order traversal to solve this problem efficiently.
1) Create an empty Queue Node and push root node to Queue.
2) Do following while nodeQeue is not empty.
a) Pop an item from Queue and process it.
a.1) If it is full node then increment count++.
b) Push left child of popped item to Queue, if available.
c) Push right child of popped item to Queue, if available.
Below is the implementation of this idea.
C++
#include <bits/stdc++.h>
using namespace std;
struct Node
{
int data;
struct Node* left, *right;
};
unsigned int getfullCount( 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 && temp->right)
count++;
if (temp->left != NULL)
q.push(temp->left);
if (temp->right != NULL)
q.push(temp->right);
}
return count;
}
struct Node* newNode( int data)
{
struct Node* node = new Node;
node->data = data;
node->left = node->right = NULL;
return (node);
}
int main( void )
{
struct Node *root = newNode(2);
root->left = newNode(7);
root->right = newNode(5);
root->left->right = newNode(6);
root->left->right->left = newNode(1);
root->left->right->right = newNode(11);
root->right->right = newNode(9);
root->right->right->left = newNode(4);
cout << getfullCount(root);
return 0;
}
|
Java
import java.util.Queue;
import java.util.LinkedList;
class Node
{
int data;
Node left, right;
public Node( int item)
{
data = item;
left = null ;
right = null ;
}
}
class BinaryTree
{
Node root;
int getfullCount()
{
if (root== null )
return 0 ;
Queue<Node> queue = new LinkedList<Node>();
queue.add(root);
int count= 0 ;
while (!queue.isEmpty())
{
Node temp = queue.poll();
if (temp.left!= null && temp.right!= null )
count++;
if (temp.left != null )
{
queue.add(temp.left);
}
if (temp.right != null )
{
queue.add(temp.right);
}
}
return count;
}
public static void main(String args[])
{
BinaryTree tree_level = new BinaryTree();
tree_level.root = new Node( 2 );
tree_level.root.left = new Node( 7 );
tree_level.root.right = new Node( 5 );
tree_level.root.left.right = new Node( 6 );
tree_level.root.left.right.left = new Node( 1 );
tree_level.root.left.right.right = new Node( 11 );
tree_level.root.right.right = new Node( 9 );
tree_level.root.right.right.left = new Node( 4 );
System.out.println(tree_level.getfullCount());
}
}
|
Python3
class Node:
def __init__( self ,key):
self .data = key
self .left = None
self .right = None
def getfullCount(root):
if root is None :
return 0
queue = []
queue.append(root)
count = 0
while ( len (queue) > 0 ):
node = queue.pop( 0 )
if node.left is not None and node.right is not None :
count = count + 1
if node.left is not None :
queue.append(node.left)
if node.right is not None :
queue.append(node.right)
return count
root = Node( 2 )
root.left = Node( 7 )
root.right = Node( 5 )
root.left.right = Node( 6 )
root.left.right.left = Node( 1 )
root.left.right.right = Node( 11 )
root.right.right = Node( 9 )
root.right.right.left = Node( 4 )
print (getfullCount(root))
|
C#
using System;
using System.Collections.Generic;
public class Node
{
public int data;
public Node left, right;
public Node( int item)
{
data = item;
left = null ;
right = null ;
}
}
public class BinaryTree
{
Node root;
int getfullCount()
{
if (root == null )
return 0;
Queue<Node> queue = new Queue<Node>();
queue.Enqueue(root);
int count = 0;
while (queue.Count != 0)
{
Node temp = queue.Dequeue();
if (temp.left != null && temp.right != null )
count++;
if (temp.left != null )
{
queue.Enqueue(temp.left);
}
if (temp.right != null )
{
queue.Enqueue(temp.right);
}
}
return count;
}
public static void Main(String []args)
{
BinaryTree tree_level = new BinaryTree();
tree_level.root = new Node(2);
tree_level.root.left = new Node(7);
tree_level.root.right = new Node(5);
tree_level.root.left.right = new Node(6);
tree_level.root.left.right.left = new Node(1);
tree_level.root.left.right.right = new Node(11);
tree_level.root.right.right = new Node(9);
tree_level.root.right.right.left = new Node(4);
Console.WriteLine(tree_level.getfullCount());
}
}
|
Javascript
<script>
class Node
{
constructor(item)
{
this .data = item;
this .left = null ;
this .right = null ;
}
}
let root;
function getfullCount()
{
if (root == null )
return 0;
let queue = [];
queue.push(root);
let count = 0;
while (queue.length != 0)
{
let temp = queue.shift();
if (temp.left != null && temp.right != null )
count++;
if (temp.left != null )
{
queue.push(temp.left);
}
if (temp.right != null )
{
queue.push(temp.right);
}
}
return count;
}
root = new Node(2);
root.left = new Node(7);
root.right = new Node(5);
root.left.right = new Node(6);
root.left.right.left = new Node(1);
root.left.right.right = new Node(11);
root.right.right = new Node(9);
root.right.right.left = new Node(4);
document.write(getfullCount());
</script>
|
Output:
2
Time Complexity: O(n)
Auxiliary Space : O(n) where, n is number of nodes in given binary tree
Method: Recursive
The idea is to traverse the tree in postorder. If the current node is full, we increment result by 1 and add returned values of left and right subtrees.
C++
#include <bits/stdc++.h>
using namespace std;
struct Node
{
int data;
struct Node* left, *right;
};
unsigned int getfullCount( struct Node* root)
{
if (root == NULL)
return 0;
int res = 0;
if (root->left && root->right)
res++;
res += (getfullCount(root->left) +
getfullCount(root->right));
return res;
}
struct Node* newNode( int data)
{
struct Node* node = new Node;
node->data = data;
node->left = node->right = NULL;
return (node);
}
int main( void )
{
struct Node *root = newNode(2);
root->left = newNode(7);
root->right = newNode(5);
root->left->right = newNode(6);
root->left->right->left = newNode(1);
root->left->right->right = newNode(11);
root->right->right = newNode(9);
root->right->right->left = newNode(4);
cout << getfullCount(root);
return 0;
}
|
Java
import java.util.*;
class GfG {
static class Node
{
int data;
Node left, right;
}
static int getfullCount(Node root)
{
if (root == null )
return 0 ;
int res = 0 ;
if (root.left != null && root.right != null )
res++;
res += (getfullCount(root.left) + getfullCount(root.right));
return res;
}
static Node newNode( int data)
{
Node node = new Node();
node.data = data;
node.left = null ;
node.right = null ;
return (node);
}
public static void main(String[] args)
{
Node root = newNode( 2 );
root.left = newNode( 7 );
root.right = newNode( 5 );
root.left.right = newNode( 6 );
root.left.right.left = newNode( 1 );
root.left.right.right = newNode( 11 );
root.right.right = newNode( 9 );
root.right.right.left = newNode( 4 );
System.out.println(getfullCount(root));
}
}
|
Python3
class newNode():
def __init__( self , data):
self .data = data
self .left = None
self .right = None
def getfullCount(root):
if (root = = None ):
return 0
res = 0
if (root.left and root.right):
res + = 1
res + = (getfullCount(root.left) +
getfullCount(root.right))
return res
if __name__ = = '__main__' :
root = newNode( 2 )
root.left = newNode( 7 )
root.right = newNode( 5 )
root.left.right = newNode( 6 )
root.left.right.left = newNode( 1 )
root.left.right.right = newNode( 11 )
root.right.right = newNode( 9 )
root.right.right.left = newNode( 4 )
print (getfullCount(root))
|
C#
using System;
class GfG
{
public class Node
{
public int data;
public Node left, right;
}
static int getfullCount(Node root)
{
if (root == null )
return 0;
int res = 0;
if (root.left != null && root.right != null )
res++;
res += (getfullCount(root.left) + getfullCount(root.right));
return res;
}
static Node newNode( int data)
{
Node node = new Node();
node.data = data;
node.left = null ;
node.right = null ;
return (node);
}
public static void Main()
{
Node root = newNode(2);
root.left = newNode(7);
root.right = newNode(5);
root.left.right = newNode(6);
root.left.right.left = newNode(1);
root.left.right.right = newNode(11);
root.right.right = newNode(9);
root.right.right.left = newNode(4);
Console.WriteLine(getfullCount(root));
}
}
|
Javascript
<script>
class Node
{
constructor()
{
this .data = 0;
this .left = null ;
this .right = null ;
}
}
function getfullCount(root)
{
if (root == null )
return 0;
var res = 0;
if (root.left != null && root.right != null )
res++;
res += (getfullCount(root.left) + getfullCount(root.right));
return res;
}
function newNode(data)
{
var node = new Node();
node.data = data;
node.left = null ;
node.right = null ;
return (node);
}
var root = newNode(2);
root.left = newNode(7);
root.right = newNode(5);
root.left.right = newNode(6);
root.left.right.left = newNode(1);
root.left.right.right = newNode(11);
root.right.right = newNode(9);
root.right.right.left = newNode(4);
document.write(getfullCount(root));
</script>
|
Output:
2
Time Complexity: O(n)
Auxiliary Space: O(n)
where, n is number of nodes in given binary tree
Similar Articles:
This article is contributed by Mr. Somesh Awasthi.
Share your thoughts in the comments
Please Login to comment...