Count number of nodes in a complete Binary Tree - GeeksforGeeks

08 Apr, 2022
Given the root of a Complete Binary Tree consisting of N nodes, the task is to find the total number of nodes in the given Binary Tree.
Examples:
Input:
Output: 7
Input:
Output: 5
Naive Approach: The simple approach to solve the given tree is to perform the DFS Traversal on the given tree and count the number of nodes in it. After traversal, print the total count of nodes obtained.
Time Complexity: O(N)Auxiliary Space: O(1) 
Efficient Approach: The above approach can also be optimized by the fact that: 
A complete binary tree has (2h – 1) nodes in total.
By this logic, in the first case, compare the left sub-tree height with the right sub-tree height. If they are equal it is a full tree, then the answer will be 2^height – 1. Otherwise, If they aren’t equal, recursively call for the left sub-tree and the right sub-tree to count the number of nodes. Follow the steps below to solve the problem:
Define a function left_height(root) and find the left height of the given Tree by traversing in the root’s left direction and store it in a variable, say leftHeight.
Define a function right_height(root) and find the right height of the given Tree by traversing in the root’s right direction and store it in a variable, say rightHeight.
Find the left and the right height of the given Tree for the current root value and if it is equal then return the value of (2height – 1) as the resultant count of nodes.
Otherwise, recursively call for the function for the left and right sub-trees and return the sum of them + 1 as the resultant count of nodes.
Below is the implementation of the above approach.
C++
C
Java
Python3
C#
Javascript
// C++ program for the above approach#include <bits/stdc++.h>using namespace std; // Structure of a Tree Nodeclass node {public:    int data;    node* left;    node* right;}; node* newNode(int data); // Function to get the left height of// the binary treeint left_height(node* node){    int ht = 0;    while (node) {        ht++;        node = node->left;    }    // Return the left height obtained    return ht;} // Function to get the right height// of the binary treeint right_height(node* node){    int ht = 0;    while (node) {        ht++;        node = node->right;    }    // Return the right height obtained    return ht;} // Function to get the count of nodes// in complete binary treeint TotalNodes(node* root){    // Base Case    if (root == NULL)        return 0;    // Find the left height and the    // right heights    int lh = left_height(root);    int rh = right_height(root);    // If left and right heights are    // equal return 2^height(1<<height) -1    if (lh == rh)        return (1 << lh) - 1;    // Otherwise, recursive call    return 1 + TotalNodes(root->left)           + TotalNodes(root->right);} // Helper function to allocate a new node// with the given datanode* newNode(int data){    node* Node = new node();    Node->data = data;    Node->left = NULL;    Node->right = NULL;    return (Node);} // Driver Codeint main(){    node* root = newNode(1);    root->left = newNode(2);    root->right = newNode(3);    root->left->left = newNode(4);    root->left->right = newNode(5);    root->right->left = newNode(9);    root->right->right = newNode(8);    root->left->left->left = newNode(6);    root->left->left->right = newNode(7);    cout << TotalNodes(root);    return 0;} // This code is contributed by aditya kumar (adityakumar129)
// C program for the above approach#include <stdio.h>#include <stdlib.h> // Structure of a Tree Nodetypedef struct node {    int data;    struct node* left;    struct node* right;}node; // Helper function to allocate a new node// with the given datanode* newNode(int data){  node * Node = (node *)malloc(sizeof(node));    Node->data = data;    Node->left = NULL;    Node->right = NULL;    return (Node);} // Function to get the left height of// the binary treeint left_height(node* node){    int ht = 0;    while (node) {        ht++;        node = node->left;    }    // Return the left height obtained    return ht;} // Function to get the right height// of the binary treeint right_height(node* node){    int ht = 0;    while (node) {        ht++;        node = node->right;    }     // Return the right height obtained    return ht;} // Function to get the count of nodes// in complete binary treeint TotalNodes(node* root){    // Base Case    if (root == NULL)        return 0;    // Find the left height and the    // right heights    int lh = left_height(root);    int rh = right_height(root);    // If left and right heights are    // equal return 2^height(1<<height) -1    if (lh == rh)        return (1 << lh) - 1;    // Otherwise, recursive call    return 1 + TotalNodes(root->left) + TotalNodes(root->right);} // Driver Codeint main(){    node* root = newNode(1);    root->left = newNode(2);    root->right = newNode(3);    root->left->left = newNode(4);    root->left->right = newNode(5);    root->right->left = newNode(9);    root->right->right = newNode(8);    root->left->left->left = newNode(6);    root->left->left->right = newNode(7);    printf("%d",TotalNodes(root));    return 0;} // This code is contributed by aditya kumar (adityakumar129)
// Java program for the above approachimport java.util.*; class GFG{ // Structure of a Tree Nodestatic class node {     int data;    node left;    node right;};  // Function to get the left height of// the binary treestatic int left_height(node node){    int ht = 0;    while (node!=null) {        ht++;        node = node.left;    }     // Return the left height obtained    return ht;} // Function to get the right height// of the binary treestatic int right_height(node node){    int ht = 0;    while (node!=null) {        ht++;        node = node.right;    }     // Return the right height obtained    return ht;} // Function to get the count of nodes// in complete binary treestatic int TotalNodes(node root){     // Base Case    if (root == null)        return 0;     // Find the left height and the    // right heights    int lh = left_height(root);    int rh = right_height(root);     // If left and right heights are    // equal return 2^height(1<<height) -1    if (lh == rh)        return (1 << lh) - 1;     // Otherwise, recursive call    return 1 + TotalNodes(root.left)           + TotalNodes(root.right);} // Helper function to allocate a new node// with the given datastatic node newNode(int data){    node Node = new node();    Node.data = data;    Node.left = null;    Node.right = null;    return (Node);} // Driver Codepublic 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);    root.right.left = newNode(9);    root.right.right = newNode(8);    root.left.left.left = newNode(6);    root.left.left.right = newNode(7);     System.out.print(TotalNodes(root)); }} // This code is contributed by shikhasingrajput
# Python program for the above approach # Structure of a Tree Nodeclass node:    def __init__(self, key):        self.left = None        self.right = None        self.val = key # Function to get the left height of# the binary treedef left_height(node):    ht = 0    while(node):        ht += 1        node = node.left              # Return the left height obtained    return ht # Function to get the right height# of the binary treedef right_height(node):    ht = 0    while(node):        ht += 1        node = node.right             # Return the right height obtained    return ht # Function to get the count of nodes# in complete binary treedef TotalNodes(root):     # Base case    if(root == None):        return 0            # Find the left height and the    # right heights    lh = left_height(root)    rh = right_height(root)          # If left and right heights are    # equal return 2^height(1<<height) -1    if(lh == rh):        return (1 << lh) - 1            # Otherwise, recursive call    return 1 + TotalNodes(root.left) + TotalNodes(root.right) # Driver coderoot = node(1)root.left = node(2)root.right = node(3)root.left.left = node(4)root.left.right = node(5)root.right.left = node(9)root.right.right = node(8)root.left.left.left = node(6)root.left.left.right = node(7) print(TotalNodes(root)) # This code is contributed by parthmanchanda81
// C# program for the above approachusing System; public class GFG{ // Structure of a Tree Nodeclass node {     public int data;    public node left;    public node right;};  // Function to get the left height of// the binary treestatic int left_height(node node){    int ht = 0;    while (node != null) {        ht++;        node = node.left;    }     // Return the left height obtained    return ht;} // Function to get the right height// of the binary treestatic int right_height(node node){    int ht = 0;    while (node != null) {        ht++;        node = node.right;    }     // Return the right height obtained    return ht;} // Function to get the count of nodes// in complete binary treestatic int TotalNodes(node root){     // Base Case    if (root == null)        return 0;     // Find the left height and the    // right heights    int lh = left_height(root);    int rh = right_height(root);     // If left and right heights are    // equal return 2^height(1<<height) -1    if (lh == rh)        return (1 << lh) - 1;     // Otherwise, recursive call    return 1 + TotalNodes(root.left)           + TotalNodes(root.right);} // Helper function to allocate a new node// with the given datastatic node newNode(int data){    node Node = new node();    Node.data = data;    Node.left = null;    Node.right = null;    return (Node);} // Driver Codepublic 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);    root.right.left = newNode(9);    root.right.right = newNode(8);    root.left.left.left = newNode(6);    root.left.left.right = newNode(7);     Console.Write(TotalNodes(root));}} // This code is contributed by shikhasingrajput
<script>        // JavaScript Program to implement        // the above approach         // Structure of a Tree Node        class Node {            constructor(data) {                this.data = data;                this.left = null;                this.right = null;            }        };          // Function to get the left height of        // the binary tree        function left_height(node) {            let ht = 0;            while (node) {                ht++;                node = node.left;            }             // Return the left height obtained            return ht;        }         // Function to get the right height        // of the binary tree        function right_height(node) {            let ht = 0;            while (node) {                ht++;                node = node.right;            }             // Return the right height obtained            return ht;        }         // Function to get the count of nodes        // in complete binary tree        function TotalNodes(root) {             // Base Case            if (root == null)                return 0;             // Find the left height and the            // right heights            let lh = left_height(root);            let rh = right_height(root);             // If left and right heights are            // equal return 2^height(1<<height) -1            if (lh == rh)                return (1 << lh) - 1;             // Otherwise, recursive call            return 1 + TotalNodes(root.left)                + TotalNodes(root.right);        }         // Helper function to allocate a new node        // with the given data         // Driver Code        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);        root.right.left = new Node(9);        root.right.right = new Node(8);        root.left.left.left = new Node(6);        root.left.left.right = new Node(7);         document.write(TotalNodes(root));      // This code is contributed by Potta Lokesh    </script>
9
 
Time Complexity: O((log N)2)Auxiliary Space: O(log N)  because of Recursion Stack Space
lokeshpotta20
shikhasingrajput
parthmanchanda81
surindertarika1234
prasanna1995
adityakumar129
Binary Tree
Complete Binary Tree
Google
interview-preparation
tree-traversal
Recursion
Tree
Google
Recursion
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Recursive Insertion Sort
Program to calculate Height and Depth of a node in a Binary Tree
Divide an array into K subarray with the given condition
Sum of natural numbers using recursion
Practice Questions for Recursion | Set 1
Tree Traversals (Inorder, Preorder and Postorder)
Binary Tree | Set 1 (Introduction)
Level Order Binary Tree Traversal
AVL Tree | Set 1 (Insertion)
Inorder Tree Traversal without Recursion