solve problem Binary Tree Inorder Traversal

Author: P-ppc

README.md

@@ -40,6 +40,7 @@ All solutions will be accepted!
 |1|[Two Sum](https://leetcode-cn.com/problems/two-sum/description/)|[java/py/js](./algorithms/TwoSum)|Easy|
 |9|[Palindrome Number](https://leetcode-cn.com/problems/palindrome-number/description/)|[java/py/js](./algorithms/PalindromeNumber)|Easy|
 |389|[Find The Difference](https://leetcode-cn.com/problems/find-the-difference/description/)|[java/py/js](./algorithms/FindTheDifference)|Easy|
+|94|[Binary Tree Inorder Traversal](https://leetcode-cn.com/problems/binary-tree-inorder-traversal/description/)|[java/py/js](./algorithms/BinaryTreeInorderTraversal)|Medium|
 
 # Database
 |596|[Big Countries](https://leetcode-cn.com/problems/big-countries/description/)|[mysql](./database/BigCountries)|Easy|

algorithms/BinaryTreeInorderTraversal/README.md

@@ -0,0 +1,22 @@
+# Binary Tree Inorder Traversal
+Use recursion can easy to solve this problem, like below:
+```
+# 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 inorderTraversal(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[int]
+        """
+        # left -> root -> right
+        if not root:
+            return []
+        return self.inorderTraversal(root.left) + [ root.val ] + self.inorderTraversal(root.right)
+```
+But we have to use iteration to solve this problem, the stack and the hashmap is the solution

algorithms/BinaryTreeInorderTraversal/Solution.java

@@ -0,0 +1,34 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public List<Integer> inorderTraversal(TreeNode root) {
+        List<TreeNode> stack = new ArrayList<TreeNode>();
+        List<Integer> res = new ArrayList<Integer>();
+        Map<TreeNode, Boolean> map = new HashMap<TreeNode, Boolean>();
+        
+        if (root == null) return res;
+        
+        stack.add(root);
+        while (stack.size() > 0) {
+            TreeNode node = stack.get(stack.size() - 1);
+            if (node.left != null && map.get(node) == null) {
+                map.put(node, true);
+                stack.add(node.left);
+            } else {
+                stack.remove(stack.size() - 1);
+                res.add(node.val);
+                if (node.right != null) {
+                    stack.add(node.right);
+                }
+            }
+        }
+        return res;
+    }
+}

algorithms/BinaryTreeInorderTraversal/solution.js

@@ -0,0 +1,33 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[]}
+ */
+var inorderTraversal = function(root) {
+    if (!root) {
+        return []
+    }
+    let stack = [root],
+        res = []
+    
+    while (stack.length > 0) {
+        let node = stack[stack.length - 1]
+        if (node.left && node.travered === undefined) {
+            node.travered = true
+            stack.push(node.left)
+        } else {
+            node = stack.pop()
+            res.push(node.val)
+            if (node.right) {
+                stack.push(node.right)
+            }
+        }
+    }
+    return res
+};

algorithms/BinaryTreeInorderTraversal/solution.py

@@ -0,0 +1,31 @@
+# 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 inorderTraversal(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[int]
+        """
+        # left -> root -> right
+        if not root:
+            return []
+        stack = [root]
+        res = []
+        traverd_map = {}
+        while len(stack) > 0:
+            node = stack[-1]
+            if node.left and traverd_map.get(node) == None:
+                traverd_map[node] = True
+                stack.append(node.left)
+            else:
+                stack.pop()
+                res.append(node.val)
+                if node.right:
+                    stack.append(node.right)
+            
+        return res