Diameter of Binary Tree
The problem
Given the root of a binary tree, return the length of the **diameter **of the tree.
The diameter of a binary tree is the length of the longest path between any two nodes in the tree. It may or may not pass through the root.
Input : root = [1, 2, 3, 4, 5] Output : 3 Explanation : The path length between node 4 and 3 is of length 3. There are other ways to reach the solution.
Input : root = [1, 2, 3, null, 4, null, 5] Output : 4 Explanation : The path length between node 4 and 5 is of length 4.
Input : root = [5, 1, 2, 8, 3, null, 5, null, 4]
- 1 <= Number of Nodes <= 104
- -100 <= Node.val <= 100
cpp
/**
* Definition for a binary tree node.
* struct TreeNode {
* int data;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int val) : data(val) , left(nullptr) , right(nullptr) {}
* };
**/
class Solution {
public:
int diameterOfBinaryTree(TreeNode* root) {
//your code goes here
}
};java
/**
* Definition for a binary tree node.
* public class TreeNode {
* int data;
* TreeNode left;
* TreeNode right;
* TreeNode(int val) { data = val; left = null, right = null }
* }
**/
class Solution {
public int diameterOfBinaryTree(TreeNode root) {
//your code goes here
}
}python
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, val=0, left=None, right=None):
# self.data = val
# self.left = left
# self.right = right
class Solution:
def diameterOfBinaryTree(self, root):
#your code goes herejavascript
/**
* Definition for a binary tree node.
* class TreeNode {
* constructor(val = 0, left = null, right = null){
* this.data = val;
* this.left = null;
* this.right = null;
* }
* }
**/
class Solution {
diameterOfBinaryTree(root) {
//your code goes here
}
}csharp
/**
* Definition for a binary tree node.
* public class TreeNode {
* public int val;
* public TreeNode left;
* public TreeNode right;
* public TreeNode(int val = 0, TreeNode left = null, TreeNode right = null) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
public class Solution {
public int DiameterOfBinaryTree(TreeNode root) {
//your code goes here
}
}go
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func diameterOfBinaryTree(root *TreeNode) int {
//your code goes here
}Stuck? Show a way to structure it+
- 01State the contract and the key invariant for Diameter of Binary Tree
- 02Return subtree heights
- 03Obtain left and right heights
- 04Update best with their sum
- 05Return one plus maximum height
- 06Validate the result against boundary cases and state O(n) time and O(h) stack space
Reference answer
Then expect these follow-ups
Which invariant proves the Diameter of Binary Tree approach is correct?
Tests: correctness reasoning
What edge case would you test first?
Tests: follow-up reasoning
Hiring now
Nvidia has 1,936 open roles right now
landed applies to roles like these for you, on each company’s own site, with answers written for the role.
Senior System Software Engineer
India, Pune
Senior E2E Hardware Architect, AI Networking
Israel, Yokneam
Senior Software Engineer - Infrastructure
India, Pune
Next question