solve problem Binary Tree Postorder Traversal

Author: P-ppc

README.md

@@ -42,6 +42,7 @@ All solutions will be accepted!
 |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|
 |144|[Binary Tree Preorder Traversal](https://leetcode-cn.com/problems/binary-tree-preorder-traversal/description/)|[java/py/js](./algorithms/BinaryTreePreorderTraversal)|Medium|
+|145|[Binary Tree Postorder Traversal](https://leetcode-cn.com/problems/binary-tree-postorder-traversal/description/)|[java/py/js](./algorithms/BinaryTreePostorderTraversal)|Hard|
 
 # Database
 |#|Title|Solution|Difficulty|

algorithms/BinaryTreePostorderTraversal/README.md

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

algorithms/BinaryTreePostorderTraversal/Solution.java

@@ -0,0 +1,39 @@
+/**
+ * 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> postorderTraversal(TreeNode root) {
+        List<Integer> res = new ArrayList<Integer>();
+        List<TreeNode> stack = new ArrayList<TreeNode>();
+        Map<TreeNode, Boolean> traveredLeftMap = new HashMap<TreeNode, Boolean>();
+        Map<TreeNode, Boolean> traveredRightMap = 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 && traveredLeftMap.get(node) == null) {
+                traveredLeftMap.put(node, true);
+                stack.add(node.left);
+            } else if (node.right != null && traveredRightMap.get(node) == null) {
+                traveredRightMap.put(node, true);
+                stack.add(node.right);
+            } else {
+                stack.remove(stack.size() - 1);
+                res.add(node.val);
+            }
+        }
+        
+        return res;
+    }
+}

algorithms/BinaryTreePostorderTraversal/solution.js

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

algorithms/BinaryTreePostorderTraversal/solution.py

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