solve problem Diameter Of Binary Tree

Author: P-ppc

README.md

@@ -144,6 +144,7 @@ All solutions will be accepted!
 |628|[Maximum Product Of Three Numbers](https://leetcode-cn.com/problems/maximum-product-of-three-numbers/description/)|[java/py/js](./algorithms/MaximumProductOfThreeNumbers)|Easy|
 |724|[Find Pivot Index](https://leetcode-cn.com/problems/find-pivot-index/description/)|[java/py/js](./algorithms/FindPivotIndex)|Easy|
 |53|[Maximum Subarray](https://leetcode-cn.com/problems/maximum-subarray/description/)|[java/py/js](./algorithms/MaximumSubarray)|Easy|
+|543|[Diameter Of Binary](https://leetcode-cn.com/problems/diameter-of-binary-tree/description/)|[java/py/js](./algorithms/DiameterOfBinary)|Easy|
 
 # Database
 |#|Title|Solution|Difficulty|

algorithms/DiameterOfBinaryTree/README.md

@@ -0,0 +1,2 @@
+# Diameter Of Binary Tree
+This problem is easy to solve by postorder traversal

algorithms/DiameterOfBinaryTree/Solution.java

@@ -0,0 +1,36 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public int diameterOfBinaryTree(TreeNode root) {
+        int diameter = 0;
+        Map<TreeNode, Integer> pathLengthMap = new HashMap<TreeNode, Integer>();
+        List<TreeNode> stack = new ArrayList<TreeNode>();
+        
+        if (root != null) stack.add(root);
+        
+        while (stack.size() > 0) {
+            TreeNode node = stack.get(stack.size() - 1);
+            
+            if (node.left != null && pathLengthMap.get(node.left) == null) {
+                stack.add(node.left);
+            } else if (node.right != null && pathLengthMap.get(node.right) == null) {
+                stack.add(node.right);
+            } else {
+                stack.remove(stack.size() - 1);
+                int leftPathLength = pathLengthMap.containsKey(node.left) ? pathLengthMap.get(node.left) : 0,
+                    rightPathLength = pathLengthMap.containsKey(node.right) ? pathLengthMap.get(node.right) : 0;
+                diameter = Math.max(diameter, leftPathLength + rightPathLength);
+                pathLengthMap.put(node, Math.max(leftPathLength, rightPathLength) + 1);
+            }
+        }
+        
+        return diameter;
+    }
+}

algorithms/DiameterOfBinaryTree/solution.js

@@ -0,0 +1,37 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var diameterOfBinaryTree = function(root) {
+    let diameter = 0,
+        pathLengthMap = new Map(),
+        stack = []
+    
+    if (root) stack.push(root)
+    
+    while (stack.length > 0) {
+        let node = stack[stack.length - 1]
+        
+        if (node.left && pathLengthMap.get(node.left) === undefined) {
+            stack.push(node.left)
+        } else if (node.right && pathLengthMap.get(node.right) === undefined) {
+            stack.push(node.right)
+        } else {
+            stack.pop()
+            let leftPathLength = pathLengthMap.get(node.left) || 0,
+                rightPathLength = pathLengthMap.get(node.right) || 0
+            
+            diameter = Math.max(diameter, leftPathLength + rightPathLength)
+            pathLengthMap.set(node, Math.max(leftPathLength, rightPathLength) + 1)
+        }
+    }
+    
+    return diameter
+};

algorithms/DiameterOfBinaryTree/solution.py

@@ -0,0 +1,34 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def diameterOfBinaryTree(self, root):
+        """
+        :type root: TreeNode
+        :rtype: int
+        """
+        diameter = 0
+        path_length_map = {}
+        stack = []
+        
+        if root: stack.append(root)
+        
+        while len(stack) > 0:
+            node = stack[-1]
+            if node.left and path_length_map.get(node.left) == None:
+                stack.append(node.left)
+            elif node.right and path_length_map.get(node.right) == None:
+                stack.append(node.right)
+            else:
+                stack.pop()
+                left_path_length = path_length_map.get(node.left, 0)
+                right_path_length = path_length_map.get(node.right, 0)
+                diameter = max(diameter, left_path_length + right_path_length)
+                path_length_map[node] = max(left_path_length, right_path_length) + 1
+        
+        return diameter
+