Open In App

Diameter of a Binary Tree using Top Down Recursion

Last Updated : 24 Jan, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report

Given a binary tree, the task is to determine the diameter of the tree. The diameter/width of a tree is defined as the number of edges on the longest path between any two nodes. 

Examples:

Input:

diameter---------of---------a---------binary---------tree---------1

Output: 2
Explanation: The longest path has 2 edges (node 2 -> node 1 -> node 3).

diameter---------of---------a---------binary---------tree---------3


Input:

diameter---------of---------a---------binary---------tree---------2

Output: 4
Explanation: The longest path has 4 edges (node 3 -> node 8 -> node 5 -> node 6 -> node 9).

diameter---------of---------a---------binary---------tree---------4

Approach:

The idea is to recursively traverse the tree using Preorder traversal. For each node, find the height of left subtree and right subtree and compare the diameter (sum of height of left subtree + height of right subtree) with the maximum diameter.

C++ 
// C++ program to find the diameter
// of a binary tree.
#include <iostream>
#include <algorithm>
using namespace std;

class Node {
public:
    int data;
    Node *left, *right;
    Node(int x) {
        data = x;
        left = nullptr;
        right = nullptr;
    }
};

// Function to compute the height of a tree.
int height(Node* root) {
  
    // Base case: tree is empty
    if (root == nullptr)
        return 0;

    // If tree is not empty then height = 1 +
    // max of left height and right heights
    return 1 + max(height(root->left), 
                   height(root->right));
}

// Function to get diameter of a binary tree
int diameter(Node* root) {
  
    if (root == nullptr)
        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 the following three:
    // 1) Diameter of left subtree
    // 2) Diameter of right subtree
    // 3) Height of left subtree + height of right subtree
    return max({lheight + rheight, ldiameter, rdiameter});
}

int main() {

    // Constructed binary tree is
    //          5
    //        /   \
    //       8     6
    //      / \   /
    //     3   7 9
    Node* root = new Node(5);
    root->left = new Node(8);
    root->right = new Node(6);
    root->left->left = new Node(3);
    root->left->right = new Node(7);
  	root->right->left = new Node(9);
    cout << diameter(root) << endl;

    return 0;
}
C 
// C program to find the diameter
// of a binary tree.
#include <stdio.h>
#include <stdlib.h>

struct Node {
    int data;
    struct Node* left;
    struct Node* right;
};

// Function to compute the height of a tree.
int height(struct Node* root) {
    
    // Base case: tree is empty
    if (root == NULL)
        return 0;

    // If tree is not empty then height = 1 +
    // max of left height and right heights
    int leftHeight = height(root->left);
    int rightHeight = height(root->right);
    
    return 1 + 
    (leftHeight > rightHeight ? leftHeight : rightHeight);
}

// Function to get diameter of a binary tree
int diameter(struct Node* 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);
    
    // Diameter of current subtree 
    int curr = lheight+rheight;

    // Return max of the following three:
    // 1) Diameter of left subtree
    // 2) Diameter of right subtree
    // 3) Height of left subtree + height of right subtree
    if (ldiameter > rdiameter && ldiameter > curr)
        return ldiameter;
    else if (rdiameter > ldiameter && rdiameter > curr) 
        return rdiameter;
    return curr;
}

struct Node* createNode(int x) {
    struct Node* newNode = 
    	(struct Node*)malloc(sizeof(struct Node));
    newNode->data = x;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

int main() {
    
    // Constructed binary tree is
    //          5
    //        /   \
    //       8     6
    //      / \   /
    //     3   7 9
    struct Node* root = createNode(5);
    root->left = createNode(8);
    root->right = createNode(6);
    root->left->left = createNode(3);
    root->left->right = createNode(7);
  	root->right->left = createNode(9);
    printf("%d\n", diameter(root));

    return 0;
}
Java 
// Java program to find the diameter
// of a binary tree.
import java.util.ArrayList;

class Node {
    int data;
    Node left, right;

    Node(int x) {
        data = x;
        left = null;
        right = null;
    }
}

class GfG {

    // Function to compute the height of a tree.
    static int height(Node root) {
        
        // Base case: tree is empty
        if (root == null)
            return 0;

        // If tree is not empty then height = 1 +
        // max of left height and right heights
        return 1 + Math.max(height(root.left), height(root.right));
    }

    // Function to get diameter of a binary tree
    static int diameter(Node 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 the following three:
        // 1) Diameter of left subtree
        // 2) Diameter of right subtree
        // 3) Height of left subtree + height
      	// of right subtree
        return Math.max(lheight + rheight, 
                        Math.max(ldiameter, rdiameter));
    }

    public static void main(String[] args) {
        
        // Constructed binary tree is
        //          5
        //        /   \
        //       8     6
        //      / \   /
        //     3   7 9
        Node root = new Node(5);
        root.left = new Node(8);
        root.right = new Node(6);
        root.left.left = new Node(3);
        root.left.right = new Node(7);
      	root.right.left = new Node(9);

        System.out.println(diameter(root));
    }
}
Python 
# Python program to find the diameter
# of a binary tree.

class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None

# Function to compute the height 
# of a tree.
def height(root):
    
    # Base case: tree is empty
    if root is None:
        return 0

    # If tree is not empty then height = 1 +
    # max of left height and right heights
    return 1 + max(height(root.left), height(root.right))

# Function to get diameter of a binary tree
def diameter(root):
    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 three:
    # 1) Diameter of left subtree
    # 2) Diameter of right subtree
    # 3) Height of left subtree + height of right subtree
    return max(lheight + rheight, ldiameter, rdiameter)

if __name__ == "__main__":
    
    # Constructed binary tree is
    #          5
    #        /   \
    #       8     6
    #      / \   /
    #     3   7 9
    root = Node(5)
    root.left = Node(8)
    root.right = Node(6)
    root.left.left = Node(3)
    root.left.right = Node(7)
    root.right.left = Node(9)

    print(diameter(root))
C# 
// C# program to find the diameter
// of a binary tree.
using System;
using System.Collections.Generic;

class Node {
    public int data;
    public Node left, right;

    public Node(int x) {
        data = x;
        left = null;
        right = null;
    }
}

class GfG {

    // Function to compute the 
    // height of a tree.
    static int height(Node root) {
        
        // Base case: tree is empty
        if (root == null)
            return 0;

        // If tree is not empty then height = 1 +
        // max of left height and right heights
        return 1 + Math.Max(height(root.left), height(root.right));
    }

    // Function to get diameter of
  	// a binary tree
    static int diameter(Node 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 the following three:
        // 1) Diameter of left subtree
        // 2) Diameter of right subtree
        // 3) Height of left subtree + height of right subtree
        return Math.Max(lheight + rheight,
                        Math.Max(ldiameter, rdiameter));
    }

    static void Main(string[] args) {
        
        // Constructed binary tree is
        //          5
        //        /   \
        //       8     6
        //      / \   /
        //     3   7 9
        Node root = new Node(5);
        root.left = new Node(8);
        root.right = new Node(6);
        root.left.left = new Node(3);
        root.left.right = new Node(7);
      	root.right.left = new Node(9);

        Console.WriteLine(diameter(root));
    }
}
JavaScript 
// JavaScript program to find the diameter
// of a binary tree.

class Node {
    constructor(x) {
        this.data = x;
        this.left = null;
        this.right = null;
    }
}

// Function to compute the height of a tree.
function height(root) {

    // Base case: tree is empty
    if (root === null)
        return 0;

    // If tree is not empty then height = 1 +
    // max of left height and right heights
    return 1 + Math.max(height(root.left), height(root.right));
}

// Function to get diameter of a binary tree
function diameter(root) {
    if (root === null)
        return 0;

    // Get the height of left and right sub-trees
    const lheight = height(root.left);
    const rheight = height(root.right);

    // Get the diameter of left and right sub-trees
    const ldiameter = diameter(root.left);
    const rdiameter = diameter(root.right);

    // Return max of the following three:
    // 1) Diameter of left subtree
    // 2) Diameter of right subtree
    // 3) Height of left subtree + height of right subtree
    return Math.max(lheight + rheight, ldiameter, rdiameter);
}

// Driver Code

// Constructed binary tree is
//          5
//        /   \
//       8     6
//      / \   /
//     3   7 9
let root = new Node(5);
root.left = new Node(8);
root.right = new Node(6);
root.left.left = new Node(3);
root.left.right = new Node(7);
root.right.left = new Node(9);

console.log(diameter(root));

Output
4

Time Complexity: O(n^2), where n is the number of nodes in tree.
Auxiliary Space: O(h) due to recursive calls.



Next Article
Diameter of a Binary Tree using Top Down Recursion

P

Pooja Kamal
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox