Related Articles

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

• Difficulty Level : Easy
• Last Updated : 28 Jun, 2021

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++

 `// C++ program to count``// full nodes in a Binary Tree``#include ``using` `namespace` `std;` `// A binary tree Node has data, pointer to left``// child and a pointer to right child``struct` `Node``{``    ``int` `data;``    ``struct` `Node* left, *right;``};` `// Function to get the count of full Nodes in``// a binary tree``unsigned ``int` `getfullCount(``struct` `Node* node)``{``    ``// If tree is empty``    ``if` `(!node)``        ``return` `0;``    ``queue 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 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 program``int` `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

 `// Java program to count``// full nodes in a Binary Tree``// using Iterative approach``import` `java.util.Queue;``import` `java.util.LinkedList;` `// Class to represent Tree node``class` `Node``{``    ``int` `data;``    ``Node left, right;` `    ``public` `Node(``int` `item)``    ``{``        ``data = item;``        ``left = ``null``;``        ``right = ``null``;``    ``}``}` `// Class to count full nodes of Tree``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 queue = ``new` `LinkedList();``        ` `        ``// 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

 `# Python program to count``# full nodes in a Binary Tree``# using iterative approach` `# A node structure``class` `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 tree``def` `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 function``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` `"%d"` `%``(getfullCount(root))`

## C#

 `// C# program to count``// full nodes in a Binary Tree``// using Iterative approach``using` `System;``using` `System.Collections.Generic;` `// Class to represent Tree node``public` `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 Tree``public` `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 queue = ``new` `Queue();``        ` `        ``// 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`

## Javascript

 ``

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++

 `// C++ program to count full nodes in a Binary Tree``#include ``using` `namespace` `std;`` ` `// A binary tree Node has data, pointer to left``// child and a pointer to right child``struct` `Node``{``    ``int` `data;``    ``struct` `Node* left, *right;``};`` ` `// Function to get the count of full Nodes in``// a binary tree``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;``}`` ` `/* 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 program``int` `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

 `// Java program to count full nodes in a Binary Tree``import` `java.util.*;``class` `GfG {` `// A binary tree Node has data, pointer to left``// child and a pointer to right child``static` `class` `Node``{``    ``int` `data;``    ``Node left, right;``}` `// Function to get the count of full Nodes in``// a binary tree``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;``}` `/* Helper function that allocates a new``Node with the given data and NULL left``and right pointers. */``static` `Node newNode(``int` `data)``{``    ``Node node = ``new` `Node();``    ``node.data = data;``    ``node.left = ``null``;``    ``node.right = ``null``;``    ``return` `(node);``}` `// Driver program``public` `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));` `}``}`

## Python3

 `# Python program to count full``# nodes in a Binary Tree``class` `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 tree``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` `        ` `# Driver code``if` `__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#

 `// C# program to count full nodes in a Binary Tree``using` `System;` `class` `GfG``{` `// A binary tree Node has data, pointer to left``// child and a pointer to right child``public` `class` `Node``{``    ``public` `int` `data;``    ``public` `Node left, right;``}` `// Function to get the count of full Nodes in``// a binary tree``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;``}` `/* Helper function that allocates a new``Node with the given data and NULL left``and right pointers. */``static` `Node newNode(``int` `data)``{``    ``Node node = ``new` `Node();``    ``node.data = data;``    ``node.left = ``null``;``    ``node.right = ``null``;``    ``return` `(node);``}` `// Driver program``public` `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 */`

## Javascript

 ``

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. 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.