Diameter of Binary Tree

The diameter of a binary tree can be defined as the number of edges between the longest paths connecting any two nodes in a binary tree. The diameter of the binary tree is also known as the width of the binary tree. The path represents the diameter of the binary tree may or may not pass through the root of the binary tree. The path includes two of the leaf nodes, among which the diameter is getting calculated.

There can be two possibilities for the longest path between two nodes representing the diameter of the binary tree:

Via Root Node: It will pass through the root node of the binary tree also counts the root node.
Not via a Root Node: In this case, the chosen path will not pass through the root node of the binary tree and will not count the root node in the path.

In the above figure 1, the longest path is between leaf node 4 and leaf node 6 that will pass through the root node 1. The diameter of the binary tree shown in figure 1 is 6, starting from leaf node 4 to leaf node 6 i.e. node 4 - node 2 - node 1 - node 3 - node 5 - node 6 also covering the root node.

Whereas in the binary tree shown in figure 2, the longest path for getting the diameter of the binary tree is starting from the leaf node 5 to the leaf node 6, but not including the root node 1. The diameter of this binary tree is 5 following the path node 5 - node 3 - node 2 - node 4 - node 6 excluding the root node 1.

Ways to Find Diameter of Binary Tree

Finding the diameter of a binary tree is a very common problem in data structures, and there are many ways to find the solution to this problem. So, now we have an idea of how to find the diameter of a binary tree, now let us look at the different ways or approaches for finding the solution to this problem statement.

There are two different ways of solving this problem recursive way and iterative way. Both ways have different approaches and different time and space complexities.

1. Recursive Way

In this way, a recursive function is used to find the height of both the subtrees with the help of this recursive function and then, with the help of the heights of both the subtrees, the diameter of the whole binary is calculated. The recursive method's time and space complexity are higher due to repeated recursive calls of the recursive function.

Now let's write a Java Code for finding the diameter of the binary tree with the help of recursion.

Code:

// A Java Program to create a  Binary tree and then find the diameter of the Binary tree

// A class named Node is written that will act as the single node of the Binary tree

class Node
{
    // the Node class has Three class variables, one of Integer type and the rest two of Node class type having names data left and right, respectively 
    
    // the data variable is of Integer type and will be used to store the value that particular node is storing in the Binary tree
    int data;

    // the left and right variables are of a Node type and will be used to store the left sub child and right sub child of the Binary tree, respectively
    Node left = null, right = null;
 
// A parameterised constructor is also written that will be used to assign the value to the data variable for storing that value in the node of the Binary tree 
    Node(int data) {
        this.data = data;
    }
}//end of Node Class
 

// A class named BinaryTree is written to find the diameter of the Binary tree and print the result
class BinaryTree
{
    // Function to find the diameter of the binary tree. Note that the
    // function returns the height of the subtree rooted at a given node,
    // and the diameter is updated within the function as it is passed by
    // reference using the `AtomicInteger` class.
    // The getDiameter Function is the recursive function that will be called repeatedly to find the heights of both the left subtree and right subtree and
    // and then those heights will be used to calculate the diameter of the Binary tree
    
public static int getDiameter(Node root, AtomicInteger diameter)
    {
        // base case: tree is empty
        if (root == null) {
            return 0;
        }
 
        // get heights of left and right subtrees
        int left_height = getDiameter(root.left, diameter);
        int right_height = getDiameter(root.right, diameter);
 
        // calculate diameter "through" the current node
        int max_diameter = left_height + right_height + 1;
 
        // update maximum diameter (note that diameter "excluding" the current
        // node in the subtree rooted at the current node is already updated
        // since we are doing postorder traversal)
        diameter.set(Math.max(diameter.get(), max_diameter));
 
        // it is important to return the height of the subtree rooted at the
        // current node
        return Math.max(left_height, right_height) + 1;
    }
 

    there is one more definition of the getDiameter function with only one parameter that will be called from the main function that
    will return the actual diameter of the Binary tree    
    public static int getDiameter(Node root)
    {
        AtomicInteger diameter = new AtomicInteger(0);
        getDiameter(root, diameter);
 
        return diameter.get();
    }
 

    //main function is written to create a Binary tree and call the getDiameter() function to get the diameter of the Binary tree
    public static void main(String[] args)
    {
       // An Object of the Node class named root is created that will represent the root node of the Binary tree whose diameter is going to be calculated 
        Node root = new Node(500);
        
        //After the creation of the root node the childs to the root nodes are attached  
        root.left = new Node(895);
        root.right = new Node(123);
        root.left.right = new Node(412);
        root.right.left = new Node(345);
        root.right.right = new Node(236);
        root.right.left.left = new Node(247);
        root.right.left.right = new Node(448);
        
        // Once all the nodes are added in the Binary tree, the getDiameter() function is called to get the diameter of the Binary tree and the root node of the Binary tree is passed as a parameter to the getDiameter() function
        int diameter = getDiameter(root);
        System.out.print("The diameter of the binary tree is " + diameter);
    }
}

Output: The output of the above code is:

The diameter of the binary tree is 6

In the above code, we have used a recursive function named getDiameter() Function that will be called repeatedly to find the heights of both the left subtree and right subtree of the binary tree then those heights will be used to calculate the diameter of the Binary tree. Because of the repeated recursive calls of the recursive function, the time complexity and space complexity is too high as compared to the iterative way.

The time complexity of finding the diameter of binary tree is: O(n^2)

The space complexity of finding the diameter of binary tree is: O(log n)

2. Iterative Way

Instead of using a recursive function, the binary tree is traversed in a depth-first search manner to find the diameter of the binary tree. As we are iterating through the binary tree in a depth-first manner, it will help us find the deepest or the farthest leaf node of the binary tree from which the path to another node will be calculated to get the diameter of the tree. Both time and space complexities are less in this method.

Here, iterative way space complexity is less than the recursive way of finding the tree's diameter because there are no repeated recursive calls that will increase these complexities.

Now let's write a code for the iterative way of finding the diameter of the binary tree.

Code:

// A Java program to create a binary tree and find the diameter of that binary tree using DFS(iterative way). 


// The ArrayList class is imported from the java.util package
import java.util.ArrayList; 
// The Arrays class is imported from the java.util package
import java.util.Arrays;
// The List class is imported from the java.util package 
import java.util.List; 

// A class named BinaryTree is created to create a binary tree and find the diameter of that binary tree
public class BinaryTree { 
// Used to track farthest or the deepest leaf node of the binary tree. 
    static int x; 
    static int maxCount; 
    // A static Object of the List class is created to store the nodes of the binary tree whose diameter is to be calculated
    static List<Integer> nodes[]; 
      
    // A static Function named findDepth is created to find the deepest element of the binary tree, which is passed as a parameter to this Function
    
    // The findDepth() Function has four parameters two of Integer type named node and count and one is a boolean array named visited to mark the visited nodes and a List of Integer types named nodes representing the nodes of the binary tree
    static void findDepth(int node, int count,boolean visited[],List<Integer> nodes[]) {

        // If that particular node is visited it is marked as true in the boolean array named visted for the particular element
        visited[node] = true; 
        // The count variable is incremented by one value 
        count++; 
          
        // The depth of that particular node is found with the help of this findDepth() Function, and the deepest value is put into the maxCount variable

        List<Integer> l = nodes[node]; 
        for(Integer i: l) 
        { 
            if(!visited[i]){ 
                if (count >= maxCount) { 
                    maxCount = count; 
                    x = i; 
                } 
                findDepth(i, count, visited, nodes); 
            } 
        } 
    } 
       
    // A static Function named dfs is written to traverse the Binary Tree and then subsequently find the deepest element of that particular Binary Tree  
    
    // The dfs() Function has three parameters two of Integer type named node and n, and the third one is a List of Integer types named nodes representing the nodes of the binary tree
    static void dfs(int node, int n, List<Integer>nodes[]) { 

        // A boolean array named visted is created to keep track of all the nodes of the binary tree that are visited
        boolean[] visited = new boolean[n + 1]; 
        int count = 0; 
       
        // Initially, all the fields of the visited array is marked as false, representing that no node is visited at the beginning of the program
        Arrays.fill(visited, false); 
       
        // Then the deepest element of the binary tree is calculated that will be used to find the diameter of the binary tree 
        findDepth(node, count + 1, visited, nodes); 
          
    } 
       
    // A static Function named diameter is written to find the diameter of the binary tree 
    
    // The diameter() Function has two parameters one is a List of Integer types named nodes representing the nodes of the binary tree,, and the other is Integer named n
    static int diameter(List<Integer> nodes[], int n) 
    { 
        
        // the maxCount variable is initialised with the minimum value of the Integers
        maxCount = Integer.MIN_VALUE; 
       

        // Firstly, the deepest nodes that are present in the binary tree are found, and once the deepest nodes are found
        // Those will be used to find the diameter of the binary tree 
        dfs(1, n, nodes); 
       
        dfs(x, n, nodes); 
        
        return maxCount; 
    } 
       
    //The main Function is written to call the diameter() Function to get the diameter of the binary tree
    public static void main(String args[]) 
    { 
        int n = 5; 
       
        /* Constructed tree is 
             1 
            / \ 
            2    3 
           / \ 
          4   5 */

        // elements are added to the nodes of the binary tree
        nodes = new List[n + 1]; 
        for(int i = 0; i < n+1 ; i++) 
            nodes[i] = new ArrayList<Integer>();  
       
        /*create undirected edges */
        nodes[1].add(2); 
        nodes[2].add(1); 
        nodes[1].add(3); 
        nodes[3].add(1); 
        nodes[2].add(4); 
        nodes[4].add(2); 
        nodes[2].add(5); 
        nodes[5].add(2); 
          
        /* maxCount will have diameter of tree */
        int diametr = diameter(nodes,n);
        System.out.println("The Diameter of the given tree is " + diametr); 
    } // end of the main class
}// end of the Binary tree class

Output: The output of the above-written code is:

The diameter of the given tree is 4

In the above code, we have calculated the diameter of the binary tree by using the iterative way. There are repeated recursive calls in the iterative method. In this method, space and time complexity are way less than the recursive method.

The time complexity of the iterative way of finding the diameter of the binary tree is O(n).

The space complexity of the iterative way of finding the diameter of the binary tree is O(n).

Next TopicHeight of Binary Tree

← prev next →