# Density of Binary Tree in One Traversal

Given a Binary Tree, find density of it by doing one traversal of it.

`Density of Binary Tree = Size / Height `

Examples:

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

Density of a Binary Tree indicates, how balanced Binary Tree is. For example density of a skewed tree is minimum and that of a perfect tree is maximum.

We strongly recommend you to minimize your browser and try this yourself first.
Two traversal based approach is very simple. First find the height using one traversal, then find the size using another traversal. Finally return the ratio of two values.
To do it in one traversal, we compute size of Binary Tree while finding its height. Below is C++ implementation.

## C++

 `//C++ program to find density of a binary tree` `#include`   `// 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 compute height and` `// size of a binary tree` `int` `heighAndSize(Node* node, ``int` `&size)` `{` `    ``if` `(node==NULL)` `        ``return` `0;`   `    ``// compute height of each subtree` `    ``int` `l = heighAndSize(node->left, size);` `    ``int` `r = heighAndSize(node->right, size);`   `    ``//increase size by 1` `    ``size++;`   `    ``//return larger of the two` `    ``return` `(l > r) ? l + 1 : r + 1;` `}`   `//function to calculate density of a binary tree` `float` `density(Node* root)` `{` `    ``if` `(root == NULL)` `        ``return` `0;`   `    ``int` `size = 0; ``// To store size`   `    ``// Finds height and size` `    ``int` `_height = heighAndSize(root, size);`   `    ``return` `(``float``)size/_height;` `}`   `// Driver code to test above methods` `int` `main()` `{` `    ``Node* root = newNode(1);` `    ``root->left = newNode(2);` `    ``root->right = newNode(3);`   `    ``printf``(``"Density of given binary tree is %f"``,` `           ``density(root));`   `    ``return` `0;` `}`

## Java

 `// Java program to find density of Binary Tree`   `// A binary tree node` `class` `Node ` `{` `    ``int` `data;` `    ``Node left, right;`   `    ``public` `Node(``int` `data) ` `    ``{` `        ``this``.data = data;` `        ``left = right = ``null``;` `    ``}` `}`   `// Class to implement pass by reference of size` `class` `Size ` `{` `    ``// variable to calculate size of tree` `    ``int` `size = ``0``;` `}`   `class` `BinaryTree ` `{` `    ``Node root;`   `    ``// Function to compute height and` `    ``// size of a binary tree` `    ``int` `heighAndSize(Node node, Size size) ` `    ``{` `        ``if` `(node == ``null``)` `            ``return` `0``;`   `        ``// compute height of each subtree` `        ``int` `l = heighAndSize(node.left, size);` `        ``int` `r = heighAndSize(node.right, size);`   `        ``//increase size by 1` `        ``size.size++;`   `        ``//return larger of the two` `        ``return` `(l > r) ? l + ``1` `: r + ``1``;` `    ``}`   `    ``//function to calculate density of a binary tree` `    ``float` `density(Node root) ` `    ``{` `        ``Size size = ``new` `Size();` `        ``if` `(root == ``null``)` `            ``return` `0``;` `               `  `        ``// Finds height and size` `        ``int` `_height = heighAndSize(root, size);`   `        ``return` `(``float``) size.size / _height;` `    ``}`   `    ``// Driver code to test above methods` `    ``public` `static` `void` `main(String[] args) ` `    ``{` `        ``BinaryTree tree = ``new` `BinaryTree();` `        ``tree.root = ``new` `Node(``1``);` `        ``tree.root.left = ``new` `Node(``2``);` `        ``tree.root.right = ``new` `Node(``3``);`   `        ``System.out.println(``"Density of given Binary Tree is : "` `                ``+ tree.density(tree.root));` `    ``}`   `}`   `// This code has been contributed by Mayank Jaiswal(mayank_24)`

## Python3

 `# Python3 program to find density` `# of a binary tree `   `# A binary tree node ` `# Helper function to allocates a new node` `class` `newNode: ` `    ``def` `__init__(``self``, data): ` `        ``self``.data ``=` `data ` `        ``self``.left ``=` `self``.right ``=` `None` `        `  `# Function to compute height and ` `# size of a binary tree ` `def` `heighAndSize(node, size): `   `    ``if` `(node ``=``=` `None``) :` `        ``return` `0`   `    ``# compute height of each subtree ` `    ``l ``=` `heighAndSize(node.left, size) ` `    ``r ``=` `heighAndSize(node.right, size) `   `    ``#increase size by 1 ` `    ``size[``0``] ``+``=` `1`   `    ``# return larger of the two ` `    ``return` `l ``+` `1` `if``(l > r) ``else` `r ``+` `1`   `# function to calculate density ` `# of a binary tree ` `def` `density(root):`   `    ``if` `(root ``=``=` `None``) :` `        ``return` `0`   `    ``size ``=` `[``0``] ``# To store size `   `    ``# Finds height and size ` `    ``_height ``=` `heighAndSize(root, size) `   `    ``return` `size[``0``] ``/` `_height `   `# Driver Code ` `if` `__name__ ``=``=` `'__main__'``:` `    ``root ``=` `newNode(``1``) ` `    ``root.left ``=` `newNode(``2``) ` `    ``root.right ``=` `newNode(``3``) `   `    ``print``(``"Density of given binary tree is "``,` `                               ``density(root))`   `# This code is contributed ` `# by SHUBHAMSINGH10`

## C#

 `// C# program to find density ` `// of Binary Tree ` `using` `System;`   `// A binary tree node ` `class` `Node ` `{ ` `    ``public` `int` `data; ` `    ``public` `Node left, right; `   `    ``public` `Node(``int` `data) ` `    ``{ ` `        ``this``.data = data; ` `        ``left = right = ``null``; ` `    ``} ` `} `   `// Class to implement pass` `// by reference of size ` `class` `Size ` `{ ` `    ``// variable to calculate` `    ``// size of tree ` `    ``public` `int` `size = 0; ` `} `   `class` `BinaryTree ` `{ ` `Node root; `   `// Function to compute height ` `// and size of a binary tree ` `int` `heighAndSize(Node node,` `                 ``Size size) ` `{ ` `    ``if` `(node == ``null``) ` `        ``return` `0; `   `    ``// compute height of each subtree ` `    ``int` `l = heighAndSize(node.left, size); ` `    ``int` `r = heighAndSize(node.right, size); `   `    ``//increase size by 1 ` `    ``size.size++; `   `    ``//return larger of the two ` `    ``return` `(l > r) ? l + 1 : r + 1; ` `} `   `// function to calculate density` `// of a binary tree ` `float` `density(Node root) ` `{ ` `    ``Size size = ``new` `Size(); ` `    ``if` `(root == ``null``) ` `        ``return` `0; ` `            `  `    ``// Finds height and size ` `    ``int` `_height = heighAndSize(root, size); `   `    ``return` `(``float``) size.size / _height; ` `} `   `// Driver code ` `static` `public` `void` `Main(String []args) ` `{ ` `    ``BinaryTree tree = ``new` `BinaryTree(); ` `    ``tree.root = ``new` `Node(1); ` `    ``tree.root.left = ``new` `Node(2); ` `    ``tree.root.right = ``new` `Node(3); `   `    ``Console.WriteLine(``"Density of given "` `+ ` `                      ``"Binary Tree is : "` `+ ` `                  ``tree.density(tree.root)); ` `} ` `} `   `// This code is contributed ` `// by Arnab Kundu`

## Javascript

 ``

Output

```Density of given binary tree is 1.500000

```

Time Complexity: O(N), where N is the number of nodes in the tree.
Space Complexity: O(H), where H is the height of the tree

### BFS Approach :

Explanation of the Breadth-First Search (BFS) approach to calculate the density of a binary tree :

• Initialize two variables, `size` and `height`, to keep track of the total number of nodes visited and the height of the tree, respectively.
• Created an empty queue for BFS traversal.
• Enqueueing by adding the root node of the binary tree to the queue.
• Begin the BFS traversal loop. At each step, process nodes level by level.
• Get the number of nodes in the current level by checking the queue size. Add `levelSize` to the `size` variable to count the total number of nodes in the tree. Increment the `height` variable to track the height of the tree.
• Now for each node in the current level, dequeue it from the queue and enqueue its left and right child nodes (if they exist) into the queue. This ensures that the next level will be processed in the next iteration of the traversal loop.
• Once the BFS traversal is complete, calculate the density of the binary tree using the formula: `Density = Size / Height`.
• Finally return the calculated density as the result of the function.

## C++

 `#include `   `// 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 a binary tree using BFS` `float` `densityBFS(Node* root)` `{` `    ``if` `(root == NULL)` `        ``return` `0;`   `    ``int` `size = 0; ``// To store size` `    ``int` `height = 0; ``// To store height`   `    ``std::queue q;` `    ``q.push(root);`   `    ``while` `(!q.empty()) {` `        ``int` `levelSize = q.size();` `        ``size += levelSize;` `        ``height++;`   `        ``for` `(``int` `i = 0; i < levelSize; i++) {` `            ``Node* current = q.front();` `            ``q.pop();`   `            ``if` `(current->left)` `                ``q.push(current->left);`   `            ``if` `(current->right)` `                ``q.push(current->right);` `        ``}` `    ``}`   `    ``return` `(``float``)size / height;` `}`   `// Driver code to test above methods` `int` `main()` `{` `    ``Node* root = newNode(1);` `    ``root->left = newNode(2);` `    ``root->right = newNode(3);`   `    ``printf``(``"Density of given binary tree is %f"``,` `           ``densityBFS(root));`   `    ``return` `0;` `}`

## Java

 `// Java Code for the above approach :`   `import` `java.util.LinkedList;` `import` `java.util.Queue;`   `// A binary tree node` `class` `Node {` `    ``int` `data;` `    ``Node left, right;`   `    ``Node(``int` `data) {` `        ``this``.data = data;` `        ``left = right = ``null``;` `    ``}` `}`   `public` `class` `BinaryTreeDensity {`   `    ``// Function to calculate density of a binary tree using BFS` `    ``static` `float` `densityBFS(Node root) {` `        ``if` `(root == ``null``)` `            ``return` `0``;`   `        ``int` `size = ``0``; ``// To store size` `        ``int` `height = ``0``; ``// To store height`   `        ``Queue queue = ``new` `LinkedList<>();` `        ``queue.add(root);`   `        ``while` `(!queue.isEmpty()) {` `            ``int` `levelSize = queue.size();` `            ``size += levelSize;` `            ``height++;`   `            ``for` `(``int` `i = ``0``; i < levelSize; i++) {` `                ``Node current = queue.poll();`   `                ``if` `(current.left != ``null``)` `                    ``queue.add(current.left);`   `                ``if` `(current.right != ``null``)` `                    ``queue.add(current.right);` `            ``}` `        ``}`   `        ``return` `(``float``) size / height;` `    ``}`   `    ``// Driver code to test above methods` `    ``public` `static` `void` `main(String[] args) {` `        ``Node root = ``new` `Node(``1``);` `        ``root.left = ``new` `Node(``2``);` `        ``root.right = ``new` `Node(``3``);`   `        ``System.out.printf(``"Density of given binary tree is %.2f"``, densityBFS(root));` `    ``}` `}`

## Python3

 `from` `queue ``import` `Queue`   `# A binary tree node` `class` `Node:` `    ``def` `__init__(``self``, data):` `        ``self``.data ``=` `data` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `# Function to calculate density of a binary tree using BFS` `def` `densityBFS(root):` `    ``if` `root ``is` `None``:` `        ``return` `0.0`   `    ``size ``=` `0`  `# To store size` `    ``height ``=` `0`  `# To store height`   `    ``q ``=` `Queue()` `    ``q.put(root)`   `    ``while` `not` `q.empty():` `        ``levelSize ``=` `q.qsize()` `        ``size ``+``=` `levelSize` `        ``height ``+``=` `1`   `        ``for` `_ ``in` `range``(levelSize):` `            ``current ``=` `q.get()`   `            ``if` `current.left:` `                ``q.put(current.left)`   `            ``if` `current.right:` `                ``q.put(current.right)`   `    ``return` `float``(size) ``/` `height`   `if` `__name__ ``=``=` `"__main__"``:` `    ``root ``=` `Node(``1``)` `    ``root.left ``=` `Node(``2``)` `    ``root.right ``=` `Node(``3``)`   `    ``density ``=` `densityBFS(root)` `    ``print``(f``"Density of given binary tree is {density:.6f}"``)`

## C#

 `using` `System;` `using` `System.Collections.Generic;`   `// A binary tree node` `class` `Node {` `    ``public` `int` `data;` `    ``public` `Node left, right;`   `    ``public` `Node(``int` `data)` `    ``{` `        ``this``.data = data;` `        ``left = right = ``null``;` `    ``}` `}`   `class` `BinaryTreeDensity {` `    ``// Function to calculate density of a binary tree using` `    ``// BFS` `    ``static` `float` `DensityBFS(Node root)` `    ``{` `        ``if` `(root == ``null``)` `            ``return` `0;`   `        ``int` `size = 0; ``// To store size` `        ``int` `height = 0; ``// To store height`   `        ``Queue q = ``new` `Queue();` `        ``q.Enqueue(root);`   `        ``while` `(q.Count > 0) {` `            ``int` `levelSize = q.Count;` `            ``size += levelSize;` `            ``height++;`   `            ``for` `(``int` `i = 0; i < levelSize; i++) {` `                ``Node current = q.Dequeue();`   `                ``if` `(current.left != ``null``)` `                    ``q.Enqueue(current.left);`   `                ``if` `(current.right != ``null``)` `                    ``q.Enqueue(current.right);` `            ``}` `        ``}`   `        ``return` `(``float``)size / height;` `    ``}`   `    ``// Driver code to test the DensityBFS method` `    ``static` `void` `Main(``string``[] args)` `    ``{` `        ``Node root = ``new` `Node(1);` `        ``root.left = ``new` `Node(2);` `        ``root.right = ``new` `Node(3);`   `        ``Console.WriteLine(` `            ``"Density of the given binary tree is "` `            ``+ DensityBFS(root));` `    ``}` `}`

## Javascript

 `class Node {` `    ``constructor(data) {` `        ``this``.data = data;` `        ``this``.left = ``null``;` `        ``this``.right = ``null``;` `    ``}` `}`   `function` `densityBFS(root) {` `    ``if` `(root === ``null``)` `        ``return` `0;`   `    ``let size = 0; ``// To store size` `    ``let height = 0; ``// To store height`   `    ``const queue = [];` `    ``queue.push(root);`   `    ``while` `(queue.length > 0) {` `        ``const levelSize = queue.length;` `        ``size += levelSize;` `        ``height++;`   `        ``for` `(let i = 0; i < levelSize; i++) {` `            ``const current = queue.shift();`   `            ``if` `(current.left !== ``null``)` `                ``queue.push(current.left);`   `            ``if` `(current.right !== ``null``)` `                ``queue.push(current.right);` `        ``}` `    ``}`   `    ``return` `size / height;` `}`   `// Driver code to test above methods` `const root = ``new` `Node(1);` `root.left = ``new` `Node(2);` `root.right = ``new` `Node(3);`   `console.log(`Density of given binary tree is \${densityBFS(root).toFixed(2)}`);`

Output

```Density of given binary tree is 1.500000

```

Time Complexity: O(N), where N is the number of nodes in the tree.
Space Complexity: O(H), where H is the height of the tree

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!