543. Diameter of Binary Tree

https://leetcode.com/problems/diameter-of-binary-tree/

Given a binary tree, you need to compute 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 a tree. This path may or may not pass through the root.

Example:

Given a binary tree

1
         / \
        2   3
       / \     
      4   5    

Return 3, which is the length of the path [4,2,1,3] or [5,2,1,3].

Note: The length of path between two nodes is represented by the number of edges between them.

---
Similar problems
124-binary-tree-maximum-path-sum
----
Intuition

At every recursive call, we want to return the longer path, so it is the best path to be combined with calling function
=> Return max (l, r) + 1 (for the edge to that node)

At every call, track global max path going through the node => l + r
---

	/**
	* Definition for a binary tree node.
	* public class TreeNode {
	* int val;
	* TreeNode left;
	* TreeNode right;
	* TreeNode() {}
	* TreeNode(int val) { this.val = val; }
	* TreeNode(int val, TreeNode left, TreeNode right) {
	* this.val = val;
	* this.left = left;
	* this.right = right;
	* }
	* }
	*/
	class Solution {
	public int diameterOfBinaryTree(TreeNode root) {
	if (root == null) {
	return 0;
	}
	int[] diameters = helper(root);
	return diameters[1] - 1;
	}
	private int[] helper(TreeNode node) {
	if (node == null) {
	return new int[] {0, 0};
	}
	int[] left = helper(node.left);
	int[] right = helper(node.right);
	int[] ans = new int[2];
	ans[0] = 1 + Math.max(left[0], right[0]);
	ans[1] = Math.max(1 + left[0] + right[0], Math.max(left[1] ,right[1]));
	return ans;
	}
	}

view raw 543.DiameterOfBinaryTreeDFSNoClassVariable.java hosted with ❤ by GitHub

	/**
	* Definition for a binary tree node.
	* public class TreeNode {
	* int val;
	* TreeNode left;
	* TreeNode right;
	* TreeNode() {}
	* TreeNode(int val) { this.val = val; }
	* TreeNode(int val, TreeNode left, TreeNode right) {
	* this.val = val;
	* this.left = left;
	* this.right = right;
	* }
	* }
	*/
	class Solution {
	int ans;
	public int diameterOfBinaryTree(TreeNode root) {
	ans = 0;
	if (root == null) {
	return ans;
	}
	dfs(root);
	return ans;
	}
	private int dfs(TreeNode node) {
	if (node == null) {
	return 0;
	}
	int l = dfs(node.left);
	int r = dfs(node.right);
	ans = Math.max(ans, l + r);
	return 1 + Math.max(l, r);
	}
	}

view raw 543.DiameterOfBinaryTreeDFSClassVariable.java hosted with ❤ by GitHub

	# Definition for a binary tree node.
	# class TreeNode:
	# def __init__(self, val=0, left=None, right=None):
	# self.val = val
	# self.left = left
	# self.right = right
	class Solution:
	def __init__(self):
	self.ans = 0
	def diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int:
	if not root:
	return ans
	self.dfs(root)
	return self.ans
	def dfs(self, node: Optional[TreeNode]) -> int:
	if not node:
	return 0
	l = self.dfs(node.left)
	r = self.dfs(node.right)
	self.ans = max(self.ans, l + r)
	return 1 + max(l, r)

view raw 543.DiameterOfBinaryTree.py hosted with ❤ by GitHub