Diameter of a Binary Tree - GeeksforGeeks

30 Mar, 2022
The diameter of a tree (sometimes called the width) is the number of nodes on the longest path between two end nodes. The diagram below shows two trees each with diameter nine, the leaves that form the ends of the longest path are shaded (note that there is more than one path in each tree of length nine, but no path longer than nine nodes). 
The diameter of a tree T is the largest of the following quantities:
the diameter of T’s left subtree.
the diameter of T’s right subtree.
the longest path between leaves that goes through the root of T (this can be computed from the heights of the subtrees of T)
Implementation: 
C++
C
Java
Python3
C#
Javascript
// Recursive optimized C program to find the diameter of a// Binary Tree#include <bits/stdc++.h>using namespace std; // A binary tree node has data, pointer to left child// and a pointer to right childstruct node {    int data;    struct node *left, *right;}; // function to create a new node of tree and returns pointerstruct node* newNode(int data); // returns max of two integersint max(int a, int b) { return (a > b) ? a : b; } // function to Compute height of a tree.int height(struct node* node); // Function to get diameter of a binary treeint diameter(struct node* tree){    // base case where tree is empty    if (tree == NULL)        return 0;     // get the height of left and right sub-trees    int lheight = height(tree->left);    int rheight = height(tree->right);     // get the diameter of left and right sub-trees    int ldiameter = diameter(tree->left);    int rdiameter = diameter(tree->right);     // Return max of following three    // 1) Diameter of left subtree    // 2) Diameter of right subtree    // 3) Height of left subtree + height of right subtree + 1    return max(lheight + rheight + 1,            max(ldiameter, rdiameter));} // UTILITY FUNCTIONS TO TEST diameter() FUNCTION // The function Compute the "height" of a tree. Height is// the number f nodes along the longest path from the root// node down to the farthest leaf node.int height(struct node* node){    // base case tree is empty    if (node == NULL)        return 0;     // If tree is not empty then height = 1 + max of left    // height and right heights    return 1 + max(height(node->left), height(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);} // Driver Codeint main(){     /* Constructed binary tree is            1            / \        2     3        / \    4     5    */    struct node* root = newNode(1);    root->left = newNode(2);    root->right = newNode(3);    root->left->left = newNode(4);    root->left->right = newNode(5);     // Function Call    cout << "Diameter of the given binary tree is " <<        diameter(root);     return 0;} // This code is contributed by shivanisinghss2110
// Recursive optimized C program to find the diameter of a// Binary Tree#include <stdio.h>#include <stdlib.h> // A binary tree node has data, pointer to left child// and a pointer to right childstruct node {    int data;    struct node *left, *right;}; // function to create a new node of tree and returns pointerstruct node* newNode(int data); // returns max of two integersint max(int a, int b) { return (a > b) ? a : b; } // function to Compute height of a tree.int height(struct node* node); // Function to get diameter of a binary treeint diameter(struct node* tree){    // base case where tree is empty    if (tree == NULL)        return 0;     // get the height of left and right sub-trees    int lheight = height(tree->left);    int rheight = height(tree->right);     // get the diameter of left and right sub-trees    int ldiameter = diameter(tree->left);    int rdiameter = diameter(tree->right);     // Return max of following three    // 1) Diameter of left subtree    // 2) Diameter of right subtree    // 3) Height of left subtree + height of right subtree + 1     return max(lheight + rheight + 1,               max(ldiameter, rdiameter));} // UTILITY FUNCTIONS TO TEST diameter() FUNCTION //  The function Compute the "height" of a tree. Height is//  the number f nodes along the longest path from the root//   node down to the farthest leaf node.int height(struct node* node){    // base case tree is empty    if (node == NULL)        return 0;     // If tree is not empty then height = 1 + max of left    // height and right heights    return 1 + max(height(node->left), height(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);} // Driver Codeint main(){     /* Constructed binary tree is              1            /   \          2      3        /  \      4     5    */    struct node* root = newNode(1);    root->left = newNode(2);    root->right = newNode(3);    root->left->left = newNode(4);    root->left->right = newNode(5);     // Function Call    printf("Diameter of the given binary tree is %d\n",           diameter(root));     return 0;}
// Recursive optimized Java program to find the diameter of// a Binary Tree // Class containing left and right child of current// node and key valueclass Node {    int data;    Node left, right;     public Node(int item)    {        data = item;        left = right = null;    }} // Class to print the Diameterclass BinaryTree {    Node root;     // Method to calculate the diameter and return it to    // main    int diameter(Node root)    {        // base case if tree is empty        if (root == null)            return 0;         // get the height of left and right sub-trees        int lheight = height(root.left);        int rheight = height(root.right);         // get the diameter of left and right sub-trees        int ldiameter = diameter(root.left);        int rdiameter = diameter(root.right);         /* Return max of following three          1) Diameter of left subtree          2) Diameter of right subtree          3) Height of left subtree + height of right subtree + 1         */        return Math.max(lheight + rheight + 1,                        Math.max(ldiameter, rdiameter));    }     // A wrapper over diameter(Node root)    int diameter() { return diameter(root); }     // The function Compute the "height" of a tree. Height    // is the number of nodes along the longest path from the    // root node down to the farthest leaf node.    static int height(Node node)    {        // base case tree is empty        if (node == null)            return 0;         // If tree is not empty then height = 1 + max of        //  left height and right heights        return (1                + Math.max(height(node.left),                           height(node.right)));    }     // Driver Code    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);         // Function Call        System.out.println(            "The diameter of given binary tree is : "            + tree.diameter());    }}
# Python3 program to find the diameter 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   # The function Compute the "height" of a tree. Height is the# number of nodes along the longest path from the root node# down to the farthest leaf node. def height(node):     # Base Case : Tree is empty    if node is None:        return 0     # If tree is not empty then height = 1 + max of left    # height and right heights    return 1 + max(height(node.left), height(node.right)) # Function to get the diameter of a binary treedef diameter(root):     # Base Case when tree is empty    if root is None:        return 0     # Get the height of left and right sub-trees    lheight = height(root.left)    rheight = height(root.right)     # Get the diameter of left and right sub-trees    ldiameter = diameter(root.left)    rdiameter = diameter(root.right)     # Return max of the following tree:    # 1) Diameter of left subtree    # 2) Diameter of right subtree    # 3) Height of left subtree + height of right subtree +1    return max(lheight + rheight + 1, max(ldiameter, rdiameter))  # Driver Code"""Constructed binary tree is            1          /   \        2      3      /  \    4     5""" root = Node(1)root.left = Node(2)root.right = Node(3)root.left.left = Node(4)root.left.right = Node(5) # Function Callprint(diameter(root)) # This code is contributed by Nikhil Kumar Singh(nickzuck_007)
// Recursive optimized C# program to find the diameter of// a Binary Tree // Class containing left and right child of current// node and key valueusing System; namespace Tree{  class Tree<T>    {        public Tree(T value)        {            this.value = value;        }        public T value { get; set; }        public Tree<T> left { get; set; }        public Tree<T> right { get; set; }    }         public class TreeDiameter    {        Tree<int> root;               // The function Compute the "height" of a tree. Height        // is the number of nodes along the longest path from the        // root node down to the farthest leaf node.        int Height(Tree<int> node)        {            if (node == null) return 0;            return 1 + Math.Max(Height(node.left),                                Height(node.right));        }        int Diameter(Tree<int> root)        {            if (root == null) return 0;             // get the height of left and right sub-trees            int lHeight = Height(root.left);            int rHeight = Height(root.right);             // get the diameter of left and right sub-trees            int lDiameter = Diameter(root.left);            int rDiameter = Diameter(root.right);           //  Return max of following three          //1) Diameter of left subtree          //2) Diameter of right subtree          //3) Height of left subtree + height of right subtree + 1                    return Math.Max(lHeight + rHeight + 1,                            Math.Max(lDiameter, rDiameter));        }         // A wrapper over diameter(Node root)        int Diameter() { return Diameter(root); }         // Driver Code        public static void Main(string[] args)        {                       // creating a binary tree and entering the nodes            TreeDiameter tree = new TreeDiameter();            tree.root = new Tree<int>(1);            tree.root.left = new Tree<int>(2);            tree.root.right = new Tree<int>(3);            tree.root.left.left = new Tree<int>(4);            tree.root.left.right = new Tree<int>(5);             Console.WriteLine($"The diameter of given binary tree is : {tree.Diameter()}");        }    }} // This code is contributed by krishaccot
<script>// JavaScript program to find the diameter of binary tree  // A binary tree nodeclass Node{      // Constructor to create a new node  constructor(data){    this.data = data    this.left = null    this.right = null  } }  // The function Compute the "height" of a tree. Height is the// number of nodes along the longest path from the root node// down to the farthest leaf node.function height(node){     // Base Case : Tree is empty    if(node == null)        return 0      // If tree is not empty then height = 1 + max of left    // height and right heights    return 1 + Math.max(height(node.left), height(node.right))}  // Function to get the diameter of a binary treefunction diameter(root){      // Base Case when tree is empty    if(root == null)        return 0      // Get the height of left and right sub-trees    let lheight = height(root.left)    let rheight = height(root.right)      // Get the diameter of left and right sub-trees    let ldiameter = diameter(root.left)    let rdiameter = diameter(root.right)      // Return max of the following tree:    // 1) Diameter of left subtree    // 2) Diameter of right subtree    // 3) Height of left subtree + height of right subtree +1    return Math.max(lheight + rheight + 1, Math.max(ldiameter, rdiameter)) }    // Driver Code // Constructed binary tree is//             1//           /   \//         2      3//       /  \//     4     5  root = new Node(1)root.left = new Node(2)root.right = new Node(3)root.left.left = new Node(4)root.left.right = new Node(5)  // Function Calldocument.write("Diameter of the given binary tree is "+diameter(root))  // This code is contributed by shinjanpatra</script>
Diameter of the given binary tree is 4
Time Complexity: O(n2) Optimized implementation: The above implementation can be optimized by calculating the height in the same recursion rather than calling a height() separately. Thanks to Amar for suggesting this optimized version. This optimization reduces time complexity to O(n).
C++
C
Java
Python3
C#
Javascript
// Recursive optimized C++ program to find the diameter of a// Binary Tree#include <bits/stdc++.h>using namespace std;  // A binary tree node has data, pointer to left child// and a pointer to right childstruct node {    int data;    struct node *left, *right;};  // function to create a new node of tree and returns pointerstruct node* newNode(int data); int diameterOpt(struct node* root, int* height){    // lh --> Height of left subtree    // rh --> Height of right subtree    int lh = 0, rh = 0;      // ldiameter  --> diameter of left subtree    // rdiameter  --> Diameter of right subtree    int ldiameter = 0, rdiameter = 0;      if (root == NULL) {        *height = 0;        return 0; // diameter is also 0    }      // Get the heights of left and right subtrees in lh and    // rh And store the returned values in ldiameter and    // ldiameter    ldiameter = diameterOpt(root->left, &lh);    rdiameter = diameterOpt(root->right, &rh);      // Height of current node is max of heights of left and    // right subtrees plus 1    *height = max(lh, rh) + 1;      return max(lh + rh + 1, max(ldiameter, rdiameter));} // 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);} // Driver Codeint main(){      /* Constructed binary tree is            1            / \        2     3        / \    4     5    */    struct node* root = newNode(1);    root->left = newNode(2);    root->right = newNode(3);    root->left->left = newNode(4);    root->left->right = newNode(5);         int height = 0;    // Function Call    cout << "Diameter of the given binary tree is " << diameterOpt(root, &height);      return 0;} // This code is contributed by probinsah.
// Recursive C program to find the diameter of a// Binary Tree#include <stdio.h> // the second parameter is to store the height of tree.// Initially, we need to pass a pointer to a location with// value as 0. So, function should be used as follows: // int height = 0;// struct node *root = SomeFunctionToMakeTree();// int diameter = diameterOpt(root, &height);int diameterOpt(struct node* root, int* height){    // lh --> Height of left subtree    // rh --> Height of right subtree    int lh = 0, rh = 0;     // ldiameter  --> diameter of left subtree    // rdiameter  --> Diameter of right subtree    int ldiameter = 0, rdiameter = 0;     if (root == NULL) {        *height = 0;        return 0; // diameter is also 0    }     // Get the heights of left and right subtrees in lh and    // rh And store the returned values in ldiameter and    // ldiameter    ldiameter = diameterOpt(root->left, &lh);    rdiameter = diameterOpt(root->right, &rh);     // Height of current node is max of heights of left and    // right subtrees plus 1    *height = max(lh, rh) + 1;     return max(lh + rh + 1, max(ldiameter, rdiameter));}
// Recursive Java program to find the diameter of a// Binary Tree // Class containing left and right child of current// node and key valueclass Node {    int data;    Node left, right;     public Node(int item)    {        data = item;        left = right = null;    }} // A utility class to pass height objectclass Height {    int h;} // Class to print the Diameterclass BinaryTree {    Node root;     // define height =0 globally and  call    // diameterOpt(root,height) from main    int diameterOpt(Node root, Height height)    {        // lh --> Height of left subtree        // rh --> Height of right subtree        Height lh = new Height(), rh = new Height();         if (root == null) {            height.h = 0;            return 0; // diameter is also 0        }/*        ldiameter  --> diameter of left subtree        rdiameter  --> Diameter of right subtree        Get the heights of left and right subtrees in lh and rh.        And store the returned values in ldiameter and ldiameter*/          int ldiameter = diameterOpt(root.left, lh);        int rdiameter = diameterOpt(root.right, rh);         // Height of current node is max of heights of left        // and right subtrees plus 1        height.h = Math.max(lh.h, rh.h) + 1;         return Math.max(lh.h + rh.h + 1,                        Math.max(ldiameter, rdiameter));    }     // A wrapper over diameter(Node root)    int diameter()    {        Height height = new Height();        return diameterOpt(root, height);    }     // The function Compute the "height" of a tree. Height    // is    //  the number f nodes along the longest path from the    //  root node down to the farthest leaf node.    static int height(Node node)    {        // base case tree is empty        if (node == null)            return 0;         // If tree is not empty then height = 1 + max of        // left height and right heights        return (1                + Math.max(height(node.left),                           height(node.right)));    }     // Driver Code    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);         // Function Call        System.out.println(            "The diameter of given binary tree is : "            + tree.diameter());    }}
# Python3 program to find the diameter of a binary tree# A binary tree Nodeclass Node:     # Constructor to create a new Node    def __init__(self, data):        self.data = data        self.left = self.right = None # utility class to pass height object class Height:    def __init(self):        self.h = 0 # Optimised recursive function to find diameter# of binary tree  def diameterOpt(root, height):     # to store height of left and right subtree    lh = Height()    rh = Height()     # base condition- when binary tree is empty    if root is None:        height.h = 0        return 0          # ldiameter --> diameter of left subtree    # rdiameter  --> diameter of right subtree         # height of left subtree and right subtree is obtained from lh and rh    # and returned value of function is stored in ldiameter and rdiameter         ldiameter = diameterOpt(root.left, lh)    rdiameter = diameterOpt(root.right, rh)     # height of tree will be max of left subtree    # height and right subtree height plus1     height.h = max(lh.h, rh.h) + 1     # return maximum of the following    # 1)left diameter    # 2)right diameter    # 3)left height + right height + 1    return max(lh.h + rh.h + 1, max(ldiameter, rdiameter)) # function to calculate diameter of binary treedef diameter(root):    height = Height()    return diameterOpt(root, height)  # Driver Coderoot = Node(1)root.left = Node(2)root.right = Node(3)root.left.left = Node(4)root.left.right = Node(5) """Constructed binary tree is            1          /   \        2      3      /  \    4     5""" # Function Callprint(diameter(root)) # This code is contributed by Shweta Singh(shweta44)
// Recursive C# program to find the diameter of a// Binary Treeusing System;using System.Collections.Generic; // Class containing left and right child of current// node and key valueclass Node{    public int data;    public Node left, right;      public Node(int item)    {        data = item;        left = right = null;    }}  // A utility class to pass height objectclass Height {    public int h;} // Class to print the Diameterclass BinaryTree {    public Node root;      // define height =0 globally and  call    // diameterOpt(root,height) from main    public int diameterOpt(Node root, Height height)    {        // lh --> Height of left subtree        // rh --> Height of right subtree        Height lh = new Height(), rh = new Height();          if (root == null) {            height.h = 0;            return 0; // diameter is also 0        }          // ldiameter  --> diameter of left subtree        // rdiameter  --> Diameter of right subtree        // Get the heights of left and right subtrees in lh        /*and rh And store the returned values in ldiameter                and ldiameter */        int ldiameter = diameterOpt(root.left, lh);        int rdiameter = diameterOpt(root.right, rh);          // Height of current node is max of heights of left        // and right subtrees plus 1        height.h = Math.Max(lh.h, rh.h) + 1;          return Math.Max(lh.h + rh.h + 1,                        Math.Max(ldiameter, rdiameter));    }      // A wrapper over diameter(Node root)    public int diameter()    {        Height height = new Height();        return diameterOpt(root, height);    }      // The function Compute the "height" of a tree. Height    // is    //  the number f nodes along the longest path from the    //  root node down to the farthest leaf node.    public int height(Node node)    {        // base case tree is empty        if (node == null)            return 0;          // If tree is not empty then height = 1 + max of        // left height and right heights        return (1                + Math.Max(height(node.left),                           height(node.right)));    }      // Driver Code    static void Main()    {               // 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);          // Function Call        Console.Write("The diameter of given binary tree is : " + tree.diameter());    }} // This code is contributed by divyesh072019.
<script>// JavaScript program to find the diameter of a binary tree// A binary tree Nodeclass Node{     // Constructor to create a new Node    constructor(data){        this.data = data        this.left = this.right = null    }} // utility class to pass height objectclass Height{    constructor()    {        this.h = 0    }} // Optimised recursive function to find diameter// of binary treefunction diameterOpt(root, height){     // to store height of left and right subtree    let lh = new Height()    let rh = new Height()     // base condition- when binary tree is empty    if(root == null)    {        height.h = 0        return 0    }          // ldiameter --> diameter of left subtree    // rdiameter  --> diameter of right subtree         // height of left subtree and right subtree is obtained from lh and rh    // and returned value of function is stored in ldiameter and rdiameter    let ldiameter = diameterOpt(root.left, lh)    let rdiameter = diameterOpt(root.right, rh)     // height of tree will be max of left subtree    // height and right subtree height plus1    height.h = Math.max(lh.h, rh.h) + 1     // return maximum of the following    // 1)left diameter    // 2)right diameter    // 3)left height + right height + 1    return Math.max(lh.h + rh.h + 1, Math.max(ldiameter, rdiameter))} // function to calculate diameter of binary treefunction diameter(root){    let height = new Height()    return diameterOpt(root, height)}  // Driver Codelet root = new Node(1)root.left = new Node(2)root.right = new Node(3)root.left.left = new Node(4)root.left.right = new Node(5)  // Constructed binary tree is//             1//           /   \//         2      3//       /  \//     4     5  // Function Calldocument.write(diameter(root)) // This code is contributed by Shinjanpatra </script>
The diameter of given binary tree is : 4
Time Complexity: O(n) 
Diameter of a Binary Tree in O(n) [A new method]Diameter of an N-ary tree
Diameter of a Binary Tree in O(n) [A new method]
Diameter of an N-ary tree
YouTubeGeeksforGeeks501K subscribersDiameter of a Binary Tree | GeeksforGeeksWatch laterShareCopy link9/200InfoShoppingTap 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 / 8:35•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=zUgxaZApKWA" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
References: http://www.cs.duke.edu/courses/spring00/cps100/assign/trees/diameter.htmlPlease write comments if you find any of the above codes/algorithms incorrect, or find other ways to solve the same problem.
shweta44
anman9801
parascoding
rahulas1505
shivanisinghss2110
krishaccot
divyesh072019
ghoshdipan
probinsah
simmytarika5
shinjanpatra
surinderdawra388
simranarora5sos
Amazon
Cadence India
Directi
MakeMyTrip
Microsoft
Oracle
OYO Rooms
Philips
Salesforce
Snapdeal
VMWare
Tree
VMWare
Amazon
Microsoft
OYO Rooms
Snapdeal
MakeMyTrip
Oracle
Directi
Philips
Salesforce
Cadence India
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Inorder Tree Traversal without Recursion
Binary Tree | Set 3 (Types of Binary Tree)
Binary Tree | Set 2 (Properties)
Decision Tree
Complexity of different operations in Binary tree, Binary Search Tree and AVL tree
Construct Tree from given Inorder and Preorder traversals
Introduction to Tree Data Structure
Expression Tree
Lowest Common Ancestor in a Binary Tree | Set 1
Sorted Array to Balanced BST