Write a program to Calculate Size of a tree | Recursion - GeeksforGeeks

13 Jan, 2022
Size of a tree is the number of elements present in the tree. Size of the below tree is 5.  
Size() function recursively calculates the size of a tree. It works as follows:Size of a tree = Size of left subtree + 1 + Size of right subtree. 
Algorithm:  
size(tree)
1. If tree is empty then return 0
2. Else
     (a) Get the size of left subtree recursively  i.e., call 
          size( tree->left-subtree)
     (a) Get the size of right subtree recursively  i.e., call 
          size( tree->right-subtree)
     (c) Calculate size of the tree as following:
            tree_size  =  size(left-subtree) + size(right-
                               subtree) + 1
     (d) Return tree_size
 
C++
C
Java
Python3
C#
Javascript
// A recursive C++ program to// calculate the size of the tree#include <bits/stdc++.h>using namespace std; /* A binary tree node has data, pointer to left childand a pointer to right child */class node{    public:    int data;    node* left;    node* right;}; /* Helper function that allocates a new node with thegiven data and NULL left and right pointers. */node* newNode(int data){    node* Node = new node();    Node->data = data;    Node->left = NULL;    Node->right = NULL;             return(Node);} /* Computes the number of nodes in a tree. */int size(node* node){    if (node == NULL)        return 0;    else        return(size(node->left) + 1 + size(node->right));} /* Driver code*/int main(){    node *root = newNode(1);    root->left = newNode(2);    root->right = newNode(3);    root->left->left = newNode(4);    root->left->right = newNode(5);         cout << "Size of the tree is " << size(root);    return 0;} // This code is contributed by rathbhupendra
#include <stdio.h>#include <stdlib.h> /* A binary tree node has data, pointer to left child   and a pointer to right child */struct node{    int data;    struct node* left;    struct node* right;}; /* 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 = (struct node*)                       malloc(sizeof(struct node));  node->data = data;  node->left = NULL;  node->right = NULL;     return(node);} /* Computes the number of nodes in a tree. */int size(struct node* node){   if (node==NULL)    return 0;  else        return(size(node->left) + 1 + size(node->right)); } /* Driver program to test size function*/   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);     printf("Size of the tree is %d", size(root));   getchar();  return 0;}
// A recursive Java program to calculate the size of the tree /* Class containing left and right child of current   node and key value*/class Node{    int data;    Node left, right;     public Node(int item)    {        data = item;        left = right = null;    }} /* Class to find size of Binary Tree */class BinaryTree{    Node root;     /* Given a binary tree. Print its nodes in level order       using array for implementing queue */    int size()    {        return size(root);    }     /* computes number of nodes in tree */    int size(Node node)    {        if (node == null)            return 0;        else            return(size(node.left) + 1 + size(node.right));    }     public static void main(String args[])    {        /* creating a binary tree and entering the nodes */        BinaryTree tree = new BinaryTree();        tree.root = new Node(1);        tree.root.left = new Node(2);        tree.root.right = new Node(3);        tree.root.left.left = new Node(4);        tree.root.left.right = new Node(5);         System.out.println("The size of binary tree is : "                            + tree.size());    }}
# Python Program to find the size of binary tree # A binary tree nodeclass Node:     # Constructor to create a new node    def __init__(self, data):        self.data = data        self.left = None        self.right = None # Computes the number of nodes in treedef size(node):    if node is None:        return 0    else:        return (size(node.left)+ 1 + size(node.right))  # Driver program to test above functionroot = Node(1)root.left = Node(2)root.right = Node(3)root.left.left  = Node(4)root.left.right = Node(5) print("Size of the tree is %d" %(size(root))) # This code is contributed by Nikhil Kumar Singh(nickzuck_007)
using System; // A recursive C# program to calculate the size of the tree /* Class containing left and right child of current   node and key value*/public class Node{    public int data;    public Node left, right;     public Node(int item)    {        data = item;        left = right = null;    }} /* Class to find size of Binary Tree */public class BinaryTree{    public Node root;     /* Given a binary tree. Print its nodes in level order       using array for implementing queue */    public virtual int size()    {        return size(root);    }     /* computes number of nodes in tree */    public virtual int size(Node node)    {        if (node == null)        {            return 0;        }        else        {            return (size(node.left) + 1 + size(node.right));        }    }     public static void Main(string[] args)    {        /* creating a binary tree and entering the nodes */        BinaryTree tree = new BinaryTree();        tree.root = new Node(1);        tree.root.left = new Node(2);        tree.root.right = new Node(3);        tree.root.left.left = new Node(4);        tree.root.left.right = new Node(5);         Console.WriteLine("The size of binary tree is : " + tree.size());    }}   //  This code is contributed by Shrikant13
<script>       // A recursive JavaScript program to      // calculate the size of the tree       /* Class containing left and right child of current         node and key value*/      class Node {        constructor(item) {          this.data = item;          this.left = null;          this.right = null;        }      }       /* Class to find size of Binary Tree */      class BinaryTree {        constructor() {          this.root = null;        }        /* computes number of nodes in tree */        size(node = this.root) {          if (node == null) {            return 0;          } else {            return this.size(node.left) + 1 + this.size(node.right);          }        }      }      /* creating a binary tree and entering the nodes */      var tree = new BinaryTree();      tree.root = new Node(1);      tree.root.left = new Node(2);      tree.root.right = new Node(3);      tree.root.left.left = new Node(4);      tree.root.left.right = new Node(5);       document.write("Size of the tree is " + tree.size() + "<br>");       </script>
Output:  
Size of the tree is 5
Time & Space Complexities: Since this program is similar to traversal of tree, time and space complexities will be same as Tree traversal (Please see our Tree Traversal post for details)  
YouTubeGeeksforGeeks507K subscribersSize of a Binary Tree | GeeksforGeeksWatch laterShareCopy linkInfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.You'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.CancelConfirmMore videosMore videosSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 4:46•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=Pivw7bIEB3I" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
?list=PLqM7alHXFySHCXD7r1J0ky9Zg_GBB1dbk 
shrikanth13
rathbhupendra
rdtank
amartyaghoshgfg
Size of a Tree
Tree
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Binary Tree | Set 3 (Types of Binary Tree)
Binary Tree | Set 2 (Properties)
Decision Tree
Introduction to Tree Data Structure
Lowest Common Ancestor in a Binary Tree | Set 1
Complexity of different operations in Binary tree, Binary Search Tree and AVL tree
Expression Tree
Deletion in a Binary Tree
Binary Tree (Array implementation)
BFS vs DFS for Binary Tree