Related Articles

Density of Binary Tree using Level Order Traversal

• Difficulty Level : Easy
• Last Updated : 21 Jul, 2021

Given a Binary Tree, find the density of it by doing one traversal of it.
The density of binary tree is defined as:

`Density of Binary Tree = Size / Height `

Examples

```Input :
Root of following tree
10
/   \
20   30

Output :  1.5
Height of given tree = 2
Size of given tree = 3

Input :
Root of the following tree
10
/
20
/
30
Output : 1
Height of given tree = 3
Size of given tree = 3 ```

The size and height of the tree can be found in single traversal using level order traversal.
To calculate the height of the binary tree the idea is to use a “NULL” pointer as a separator between two levels. Whenever “NULL” occurs during the traversal, height is incremented.
To calculate the size of the binary tree, increment the counter for every new node encountered during the level order traversal.
Finally, use the above formula to calculate the density of the Binary Tree.

Below is the implementation of the above approach:

C++

 `// C++ implementation of the above approach``#include ``using` `namespace` `std;` `// A binary tree node``struct` `Node {``    ``int` `data;``    ``Node *left, *right;``};` `// Helper function to allocates a new node``Node* newNode(``int` `data)``{``    ``Node* node = ``new` `Node;``    ``node->data = data;``    ``node->left = node->right = NULL;``    ``return` `node;``}` `// Function to calculate density of Binary Tree``float` `density(Node* root)``{``    ``queue q;` `    ``// push root to queue first``    ``q.push(root);``    ` `    ``// push NULL as a separator``    ``q.push(NULL);``    ``int` `height = 1, size = 0;``    ``while` `(!q.empty()) {``        ``Node* t = q.front();``        ``q.pop();``        ``if` `(t)``            ``size++;``        ``else` `{` `            ``// If after popping NULL queue is``            ``// empty then get out of loop i.e``            ``// stop the level order traversal.``            ``if` `(q.empty())``                ``break``;``            ``q.push(NULL);``            ``height++;``            ``continue``;``        ``}` `        ``// if t has left child``        ``// then push it to queue``        ``if` `(t->left) {``            ``q.push(t->left);``        ``}` `        ``// if t has right child``        ``// then push it to queue``        ``if` `(t->right) {``            ``q.push(t->right);``        ``}``    ``}``    ``return` `(``float``)size / height;``}` `// Driver code``int` `main()``{``    ``Node* root = newNode(1);``    ``root->left = newNode(2);``    ``root->right = newNode(3);` `    ``cout << density(root) << endl;``    ``return` `0;``}`

Java

 `// Java implementation of the above approach``import` `java.util.*;` `class` `Solution``{` `// A binary tree node``static` `class` `Node``{``    ``int` `data;``    ``Node left, right;``}` `// Helper function to allocates a new node``static` `Node newNode(``int` `data)``{``    ``Node node = ``new` `Node();``    ``node.data = data;``    ``node.left = node.right = ``null``;``    ``return` `node;``}` `// Function to calculate density of Binary Tree``static` `float` `density(Node root)``{``    ``Queue q = ``new` `LinkedList();` `    ``// add root to queue first``    ``q.add(root);``    ` `    ``// add null as a separator``    ``q.add(``null``);``    ``int` `height = ``1``, size = ``0``;``    ``while` `(q.size() > ``0``)``    ``{``        ``Node t = q.peek();``        ``q.remove();``        ``if` `(t != ``null``)``            ``size++;``        ``else``        ``{` `            ``// If after removeping null queue is``            ``// empty then get out of loop i.e``            ``// stop the level order traversal.``            ``if` `(q.size() == ``0``)``                ``break``;``            ``q.add(``null``);``            ``height++;``            ``continue``;``        ``}` `        ``// if t has left child``        ``// then add it to queue``        ``if` `(t.left !=``null``)``        ``{``            ``q.add(t.left);``        ``}` `        ``// if t has right child``        ``// then add it to queue``        ``if` `(t.right != ``null``)``        ``{``            ``q.add(t.right);``        ``}``    ``}``    ``return` `((``float``)size )/ height;``}` `// Driver code``public` `static` `void` `main(String args[])``{``    ``Node root = newNode(``1``);``    ``root.left = newNode(``2``);``    ``root.right = newNode(``3``);` `    ``System.out.println(density(root));``}``}` `// This code is contributed by Arnab Kundu`

Python3

 `# Python implementation of the above approach` `# Linked List node``class` `Node:``    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `# Helper function to allocates a new node``def` `newNode( data) :` `    ``node ``=` `Node(``0``)``    ``node.data ``=` `data``    ``node.left ``=` `node.right ``=` `None``    ``return` `node` `# Function to calculate density of Binary Tree``def` `density(root) :` `    ``q ``=` `[]` `    ``# append root to queue first``    ``q.append(root)``    ` `    ``# append None as a separator``    ``q.append(``None``)``    ``height ``=` `1``    ``size ``=` `0``    ``while` `(``len``(q) > ``0``):``        ``t ``=` `q[``0``]``        ``q.pop(``0``)``        ``if` `(t !``=` `None``):``            ``size ``=` `size ``+` `1``        ``else``:` `            ``# If after removeping None queue is``            ``# empty then get out of loop i.e``            ``# stop the level order traversal.``            ``if` `(``len``(q) ``=``=` `0``):``                ``break``            ``q.append(``None``)``            ``height ``=` `height ``+` `1``            ``continue` `        ``# if t has left child``        ``# then append it to queue``        ``if` `(t.left !``=` `None``) :``            ``q.append(t.left)` `        ``# if t has right child``        ``# then append it to queue``        ``if` `(t.right !``=` `None``):``        ` `            ``q.append(t.right)` `    ``return` `(size ) ``/` `height` `# Driver code` `root ``=` `newNode(``1``)``root.left ``=` `newNode(``2``)``root.right ``=` `newNode(``3``)` `print``(density(root))` `# This code is contributed by Arnab Kundu`

C#

 `// C# implementation of the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{` `// A binary tree node``public` `class` `Node``{``    ``public` `int` `data;``    ``public` `Node left, right;``}` `// Helper function to allocates a new node``static` `Node newNode(``int` `data)``{``    ``Node node = ``new` `Node();``    ``node.data = data;``    ``node.left = node.right = ``null``;``    ``return` `node;``}` `// Function to calculate density of Binary Tree``static` `float` `density(Node root)``{``    ``Queue q = ``new` `Queue();` `    ``// add root to queue first``    ``q.Enqueue(root);``    ` `    ``// add null as a separator``    ``q.Enqueue(``null``);``    ``int` `height = 1, size = 0;``    ``while` `(q.Count > 0)``    ``{``        ``Node t = q.Peek();``        ``q.Dequeue();``        ``if` `(t != ``null``)``            ``size++;``        ``else``        ``{` `            ``// If after removeping null queue is``            ``// empty then get out of loop i.e``            ``// stop the level order traversal.``            ``if` `(q.Count == 0)``                ``break``;``            ``q.Enqueue(``null``);``            ``height++;``            ``continue``;``        ``}` `        ``// if t has left child``        ``// then add it to queue``        ``if` `(t.left !=``null``)``        ``{``            ``q.Enqueue(t.left);``        ``}` `        ``// if t has right child``        ``// then add it to queue``        ``if` `(t.right != ``null``)``        ``{``            ``q.Enqueue(t.right);``        ``}``    ``}``    ``return` `((``float``)size ) / height;``}` `// Driver code``public` `static` `void` `Main(String []args)``{``    ``Node root = newNode(1);``    ``root.left = newNode(2);``    ``root.right = newNode(3);` `    ``Console.WriteLine(density(root));``}``}` `// This code is contributed by PrinciRaj1992`

Javascript

 ``
Output:

`1.5`

Time Complexity : O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up