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   30
Output: 1.5
Height of given tree = 2
Size of given tree = 3
Input: Root of following tree
     10
    /   
   20   
 /
30
Output: 1
Height of given tree = 3
Size 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<bits/stdc++.h>

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

<script>

// javascript program to find density
// of Binary Tree

// A binary tree node
class Node
{
  constructor(data)
  {
    this.data = data;
    this.left = null;
    this.right = null;
  }
}

// Class to implement pass
// by reference of size
class Size
{
  constructor()
  {
    // variable to calculate
    // size of tree
    this.size = 0;
  }
}


var root = null;

// Function to compute height
// and size of a binary tree
function heighAndSize(node, size)
{
    if (node == null)
        return 0;

    // compute height of each subtree
    var l = heighAndSize(node.left, size);
    var 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
function density(root)
{
    var size = new Size();
    if (root == null)
        return 0;

    // Finds height and size
    var _height = heighAndSize(root, size);

    return size.size / _height;
}

// Driver code
root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
document.write("Density of given " +
                  "Binary Tree is : " +
              density(root));

// This code is contributed by itsok.

</script>

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 <bits/stdc++.h>

// 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<Node*> 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<Node> 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<Node> q = new Queue<Node>();
        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