Count full nodes in a Binary tree (Iterative and Recursive)

28 Jan, 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. 
Chapters
descriptions off, selected
captions settings, opens captions settings dialog
captions off, selected
English
This is a modal window.
Beginning of dialog window. Escape will cancel and close the window.
End of dialog window.
C++
Java
Python3
C#
Javascript
// C++ program to count// full nodes in a Binary Tree#include <bits/stdc++.h>using namespace std; // A binary tree Node has data, pointer to left// child and a pointer to right childstruct Node{    int data;    struct Node* left, *right;}; // Function to get the count of full Nodes in// a binary treeunsigned int getfullCount(struct Node* node){    // If tree is empty    if (!node)        return 0;    queue<Node *> q;         // Do level order traversal starting from root    int count = 0; // Initialize count of full nodes    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;} /* Helper function that allocates a new Node with thegiven data and NULL left and right pointers. */struct Node* newNode(int data){    struct Node* node = new Node;    node->data = data;    node->left = node->right = NULL;    return (node);} // Driver programint main(void){    /* 2     / \    7     5    \     \     6     9    / \ /    1 11 4    Let us create Binary Tree as shown    */         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 program to count// full nodes in a Binary Tree// using Iterative approachimport java.util.Queue;import java.util.LinkedList; // Class to represent Tree nodeclass Node{    int data;    Node left, right;     public Node(int item)    {        data = item;        left = null;        right = null;    }} // Class to count full nodes of Treeclass BinaryTree{     Node root;     /* Function to get the count of full Nodes in    a binary tree*/    int getfullCount()    {        // If tree is empty        if (root==null)        return 0;                 // Initialize empty queue.        Queue<Node> queue = new LinkedList<Node>();                 // Do level order traversal starting from root        queue.add(root);                 int count=0; // Initialize count of full nodes        while (!queue.isEmpty())        {             Node temp = queue.poll();            if (temp.left!=null && temp.right!=null)            count++;             // Enqueue left child            if (temp.left != null)            {                queue.add(temp.left);            }             // Enqueue right child            if (temp.right != null)            {                queue.add(temp.right);            }        }        return count;    }     public static void main(String args[])    {        /* 2          / \        7     5        \     \        6     9        / \ /        1 11 4        Let us create Binary Tree as shown        */        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());             }}
# Python program to count# full nodes in a Binary Tree# using iterative approach # A node structureclass Node:    # A utility function to create a new node    def __init__(self ,key):        self.data = key        self.left = None        self.right = None # Iterative Method to count full nodes of binary treedef getfullCount(root):    # Base Case    if root is None:        return 0         # Create an empty queue for level order traversal    queue = []     # Enqueue Root and initialize count    queue.append(root)             count = 0 #initialize count for full nodes    while(len(queue) > 0):        node = queue.pop(0)         # if it is full node then increment count        if node.left is not None and node.right is not None:            count = count+1         # Enqueue left child        if node.left is not None:            queue.append(node.left)         # Enqueue right child        if node.right is not None:            queue.append(node.right)                 return count # Driver Program to test above functionroot = 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# program to count// full nodes in a Binary Tree// using Iterative approachusing System;using System.Collections.Generic; // Class to represent Tree nodepublic class Node{    public int data;    public Node left, right;     public Node(int item)    {        data = item;        left = null;        right = null;    }} // Class to count full nodes of Treepublic class BinaryTree{     Node root;     /* Function to get the count of full Nodes in    a binary tree*/    int getfullCount()    {        // If tree is empty        if (root == null)        return 0;                 // Initialize empty queue.        Queue<Node> queue = new Queue<Node>();                 // Do level order traversal starting from root        queue.Enqueue(root);                 int count = 0; // Initialize count of full nodes        while (queue.Count != 0)        {             Node temp = queue.Dequeue();            if (temp.left != null && temp.right != null)            count++;             // Enqueue left child            if (temp.left != null)            {                queue.Enqueue(temp.left);            }             // Enqueue right child            if (temp.right != null)            {                queue.Enqueue(temp.right);            }        }        return count;    }     // Driver code    public static void Main(String []args)    {        /* 2        / \        7 5        \ \        6 9        / \ /        1 11 4        Let us create Binary Tree as shown        */        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());    }} // This code has been contributed by 29AjayKumar
<script> // Javascript program to count// full nodes in a Binary Tree// using Iterative approach // Class to represent Tree nodeclass Node{    constructor(item)    {        this.data = item;        this.left = null;        this.right = null;    }}let root; // Function to get the count of full// Nodes in a binary treefunction getfullCount(){         // If tree is empty    if (root == null)        return 0;           // Initialize empty queue.    let queue = [];           // Do level order traversal starting from root    queue.push(root);         // Initialize count of full nodes    let count = 0;         while (queue.length != 0)    {        let temp = queue.shift();        if (temp.left != null && temp.right != null)            count++;         // Enqueue left child        if (temp.left != null)        {            queue.push(temp.left);        }         // Enqueue right child        if (temp.right != null)        {            queue.push(temp.right);        }    }    return count;} // Driver code/* 2  / \7     5\     \ 6     9/ \  /1 11 4Let us create Binary Tree as shown*/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()); // This code is contributed by rag2127 </script>
Output: 
 2
Time Complexity: O(n) Auxiliary Space : O(n) where, n is number of nodes in given binary tree
Method: RecursiveThe 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++
Java
Python3
C#
Javascript
// C++ program to count full nodes in a Binary Tree#include <bits/stdc++.h>using namespace std;  // A binary tree Node has data, pointer to left// child and a pointer to right childstruct Node{    int data;    struct Node* left, *right;};  // Function to get the count of full Nodes in// a binary treeunsigned 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;}  /* Helper function that allocates a new   Node with the given data and NULL left   and right pointers. */struct Node* newNode(int data){    struct Node* node = new Node;    node->data = data;    node->left = node->right = NULL;    return (node);}  // Driver programint main(void){    /* 2     / \    7    5    \    \     6   9    / \ /    1 11 4    Let us create Binary Tree as shown    */      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 program to count full nodes in a Binary Treeimport java.util.*;class GfG { // A binary tree Node has data, pointer to left// child and a pointer to right childstatic class Node{    int data;    Node left, right;} // Function to get the count of full Nodes in// a binary treestatic 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;} /* Helper function that allocates a newNode with the given data and NULL leftand right pointers. */static Node newNode(int data){    Node node = new Node();    node.data = data;    node.left = null;    node.right = null;    return (node);} // Driver programpublic static void main(String[] args){    /* 2    / \    7 5    \ \    6 9    / \ /    1 11 4    Let us create Binary Tree as shown    */     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)); }}
# Python program to count full# nodes in a Binary Treeclass newNode():     def __init__(self, data):        self.data = data        self.left = None        self.right = None                  # Function to get the count of # full Nodes in a binary treedef 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          # Driver codeif __name__ == '__main__':    """ 2    / \    7 5    \ \    6 9    / \ /    1 11 4    Let us create Binary Tree as shown    """         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)) # This code is contributed by SHUBHAMSINGH10
// C# program to count full nodes in a Binary Treeusing System; class GfG{ // A binary tree Node has data, pointer to left// child and a pointer to right childpublic class Node{    public int data;    public Node left, right;} // Function to get the count of full Nodes in// a binary treestatic 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;} /* Helper function that allocates a newNode with the given data and NULL leftand right pointers. */static Node newNode(int data){    Node node = new Node();    node.data = data;    node.left = null;    node.right = null;    return (node);} // Driver programpublic static void Main(){    /* 2    / \    7 5    \ \    6 9    / \ /    1 11 4    Let us create Binary Tree as shown    */     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));}} /* This code contributed by PrinciRaj1992 */
<script> // JavaScript program to count full nodes in a Binary Tree // A binary tree Node has data, pointer to left// child and a pointer to right childclass Node{    constructor()    {        this.data = 0;        this.left = null;        this.right = null;    }} // Function to get the count of full Nodes in// a binary treefunction 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;} /* Helper function that allocates a newNode with the given data and NULL leftand right pointers. */function newNode(data){    var node = new Node();    node.data = data;    node.left = null;    node.right = null;    return (node);} // Driver program/* 2/ \7 5\ \6 9/ \ /1 11 4Let us create Binary Tree as shown*/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 
Iterative method to Count full nodes in a Binary tree | GeeksforGeeks - YouTubeGeeksforGeeks529K subscribersIterative method to Count full nodes in a Binary tree | GeeksforGeeksWatch laterShareCopy linkInfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.More videosMore videosYou're signed outVideos you watch may be added to the TV's watch history and influence TV recommendations. To avoid this, cancel and sign in to YouTube on your computer.CancelConfirmSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 6:31•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=yDY1Nfi0ipo" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
Similar Articles: 
Count half nodes in a Binary tree (Iterative and Recursive)
Program to get count of leaf nodes in Binary Tree
Given a binary tree, how do you remove all the half nodes?
Print all full nodes in a Binary Tree
This article is contributed by Mr. Somesh Awasthi. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
prerna saini
princiraj1992
SHUBHAMSINGH10
29AjayKumar
rag2127
famously
amartyaghoshgfg
Tree
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Introduction to Data Structures
Introduction to Tree Data Structure
What is Data Structure: Types, Classifications and Applications
Binary Tree | Set 3 (Types of Binary Tree)
Binary Tree | Set 2 (Properties)
Diameter of a Binary Tree
Lowest Common Ancestor in a Binary Tree | Set 1
Decision Tree
Diagonal Traversal of Binary Tree
Insertion in a Binary Tree in level order