Diameter of Binary Tree - Practice Coding Problems

Diameter of Binary Tree - Problem

The diameter of a binary tree is one of the most elegant tree problems that challenges your understanding of tree traversal and path calculations.

Given the root of a binary tree, you need to find the length of the longest path between any two nodes in the tree. This path represents the tree's "diameter" - imagine stretching the tree as wide as possible.

Key Points:

The path may or may not pass through the root
The path length is measured by the number of edges (not nodes)
You need to consider all possible paths, not just root-to-leaf paths

For example, in a tree where the longest path goes from one leaf, up through several ancestors, and down to another leaf on the opposite side, that entire journey's edge count is your answer.

Input & Output

example_1.py — Basic Binary Tree

$ Input: [1,2,3,4,5]

› Output: 3

💡 Note: The longest path is from node 4 to node 5, passing through nodes 2 and then to node 3. Path: 4->2->5 would be length 2, but 4->2->1->3 is length 3.

example_2.py — Single Node

$ Input: [1]

› Output: 0

💡 Note: A single node has no edges, so the diameter is 0.

example_3.py — Skewed Tree

$ Input: [1,2,null,3,null,4,null]

› Output: 3

💡 Note: The longest path goes from node 4 to node 1, passing through nodes 3 and 2. This gives us 3 edges total.

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
-100 ≤ Node.val ≤ 100
Tree nodes contain integer values only

Visualization

Tap to expand

Understanding the Visualization

Identify All Paths

Every possible path between two nodes could potentially be the diameter

Key Insight

The longest path must pass through some node as the highest common ancestor

Calculate at Each Node

For each node, the longest path through it equals left subtree height + right subtree height

Single Traversal

Use post-order DFS to calculate heights and track maximum diameter simultaneously

Key Takeaway

🎯 Key Insight: The diameter of any subtree can be calculated by summing the maximum depths of its left and right children, making post-order traversal perfect for this problem.

Asked in

G Google 28 a Amazon 22 ⊞ Microsoft 18 f Meta 15 Apple 12

The optimal solution uses post-order DFS traversal to calculate both height and diameter in a single pass. For each node, we compute the heights of left and right subtrees, update the maximum diameter as left_height + right_height, then return the current subtree's height. This achieves O(n) time complexity by visiting each node exactly once.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Calculate All Paths)	O(n²)	O(h)	For each node, calculate the longest path passing through it
One-Pass DFS (Optimal)	O(n)	O(h)	Calculate height and diameter in a single traversal using post-order DFS

Brute Force (Calculate All Paths) — Algorithm Steps

For each node in the tree, calculate the height of its left subtree
Calculate the height of its right subtree
The diameter through this node is left_height + right_height
Keep track of the maximum diameter found
Return the maximum diameter across all nodes

Visualization

Tap to expand

Step-by-Step Walkthrough

Visit Node A

Calculate height of left subtree (traverse entire left side)

Calculate Right Height

Calculate height of right subtree (traverse entire right side)

Record Diameter

Sum left + right heights for this node's diameter

Repeat Process

Move to next node and repeat entire height calculation

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

// Definition for a binary tree node
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

int height(struct TreeNode* node) {
    if (node == NULL) return 0;
    int leftH = height(node->left);
    int rightH = height(node->right);
    return 1 + (leftH > rightH ? leftH : rightH);
}

int diameterOfBinaryTree(struct TreeNode* root) {
    if (root == NULL) return 0;
    
    int maxDiameter = 0;
    struct TreeNode* stack[10000];
    int top = -1;
    
    stack[++top] = root;
    
    while (top >= 0) {
        struct TreeNode* node = stack[top--];
        
        int leftHeight = height(node->left);
        int rightHeight = height(node->right);
        int currentDiameter = leftHeight + rightHeight;
        
        if (currentDiameter > maxDiameter) {
            maxDiameter = currentDiameter;
        }
        
        if (node->left) stack[++top] = node->left;
        if (node->right) stack[++top] = node->right;
    }
    
    return maxDiameter;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we calculate height which takes O(n) time in worst case

⚠ Quadratic Growth

Space Complexity

O(h)

Recursion depth equals tree height h, O(log n) for balanced tree, O(n) for skewed tree

✓ Linear Space

87.2K Views

High Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Calculate All Paths) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler