94_Binary_Tree_Inorder_Traversal

145_Binary_Tree_Postorder_Traversal

Author: qiyuangong

README.md

@@ -33,6 +33,7 @@
 | 66 | [Plus One](https://leetcode.com/problems/plus-one/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/66_Plus_One.py) | Check if current digit == 9. |
 | 70 | [Climbing Stairs](https://leetcode.com/problems/climbing-stairs/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/70_Climbing_Stairs.py) | Bottom-up DP, dp[i] = dp[i - 2] + dp[i- 1] <br>1. O(n) and O(n)<br>2. Only two variables are needed, O(n) and O(1) |
 | 72 | [Edit Distance](https://leetcode.com/problems/edit-distance/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/72_Edit_Distance.py) | [Background](https://en.wikipedia.org/wiki/Edit_distance)<br> 1. DP O(n^2) space<br>2. DP O(n) space |
+| 94 | [Binary Tree Inorder Traversal](https://leetcode.com/problems/binary-tree-inorder-traversal/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/94_Binary_Tree_Inorder_Traversal.py) | 1. Recursion, O(n) and O(1)<br>2. Stack and check isinstance(curr, TreeNode), O(n) and O(n)<br>3. Stack and check left and right, O(n) and O(n) |
 | 98 | [Validate Binary Search Tree](https://leetcode.com/problems/validate-binary-search-tree/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/98_Validate_Binary_Search_Tree.py) | 1. Stack O(n) and O(n)<br>2. Recursion O(n) and O(n) |
 | 104 | [Maximum Depth of Binary Tree](https://leetcode.com/problems/maximum-depth-of-binary-tree/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/104_Maximum_Depth_of_Binary_Tree.py)| Recursion max(left, right) + 1 |
 | 108 | [Convert Sorted Array to Binary Search Tree](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/108_Convert_Sorted_Array_to_Binary_Search_Tree.py)| Recursion O(n) and O(nlgn)|
@@ -50,7 +51,7 @@
 | 142 | [Linked List Cycle II](https://discuss.leetcode.com/topic/2975/o-n-solution-by-using-two-pointers-without-change-anything) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/142_Linked_List_Cycle_II.py) | Two points, a+b=nr |
 | 143 | [Reorder List](https://leetcode.com/problems/reorder-list/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/143_Reorder_List.py) | 1. List as index to rebuild relation, O(n) and O(n)<br>2. Two points, O(n) and O(1) |
 | 144 | [Binary Tree Preorder Traversal](https://leetcode.com/problems/binary-tree-preorder-traversal/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/144_Binary_Tree_Preorder_Traversal.py) | 1. Recursion, O(n) and O(n)<br>2. Stack, O(n) and O(n) |
-| 145 | [Binary Tree Postorder Traversal](https://leetcode.com/problems/binary-tree-postorder-traversal/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/145_Binary_Tree_Postorder_Traversal.py) | 1. Recursion, O(n) and O(n)<br>2. Stack, O(n) and O(n)  |
+| 145 | [Binary Tree Postorder Traversal](https://leetcode.com/problems/binary-tree-postorder-traversal/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/145_Binary_Tree_Postorder_Traversal.py) | 1. Recursion, O(n) and O(n)<br>2. Stack and queue (insert 0), O(n) and O(n)<br>3. Stack and isinstance(curr, TreeNode), O(n) and O(n) |
 | 146 | [LRU Cache](https://leetcode.com/problems/lru-cache/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/146_LRU_Cache.py) | 1. Queue and dict<br>2. OrderedDict |
 | 150 | [Evaluate Reverse Polish Notation](https://leetcode.com/problems/evaluate-reverse-polish-notation/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/150_Evaluate_Reverse_Polish_Notation.py) | Stack |
 | 151 | [Reverse Words in a String](https://discuss.leetcode.com/category/159/reverse-words-in-a-string) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/151_Reverse_Words_in_a_String.py)| 1. Python split by space <br>2. Reverse all and reverse words |

python/145_Binary_Tree_Postorder_Traversal.py

@@ -25,17 +25,33 @@ class Solution(object):
     #     self.postorderHelp(node.right, stack)
     #     stack.append(node.val)
 
+    # def postorderTraversal(self, root):
+    #     # Stack
+    #     if root is None:
+    #         return []
+    #     res = []
+    #     stack = [root]
+    #     while len(stack) > 0:
+    #         curr = stack.pop()
+    #         res.insert(0, curr.val)
+    #         if curr.left is not None:
+    #             stack.append(curr.left)
+    #         if curr.right is not None:
+    #             stack.append(curr.right)
+    #     return res
+
     def postorderTraversal(self, root):
-        # Stack
         if root is None:
             return []
-        res = []
-        stack = [root]
+        res = []; stack = [root]
         while len(stack) > 0:
             curr = stack.pop()
-            res.insert(0, curr.val)
-            if curr.left is not None:
-                stack.append(curr.left)
+            if not isinstance(curr, TreeNode):
+                res.append(curr)
+                continue
+            stack.append(curr.val)
             if curr.right is not None:
                 stack.append(curr.right)
+            if curr.left is not None:
+                stack.append(curr.left)
         return res

python/94_Binary_Tree_Inorder_Traversal.py

@@ -44,18 +44,36 @@ class Solution(object):
     #                 queue.insert(0, curr.left)
     #                 curr.left = None
     #     return res
+    # def inorderTraversal(self, root):
+    #     res = []
+    #     stack = []
+    #     while root is not None:
+    #         stack.append(root)
+    #         root = root.left
+    #         while root is None:
+    #             if len(stack) == 0:
+    #                 return res
+    #             root = stack.pop()
+    #             res.append(root.val)
+    #             root = root.right
+    #     return res
+
     def inorderTraversal(self, root):
+        if root is None:
+            return []
         res = []
-        stack = []
-        while root is not None:
-            stack.append(root)
-            root = root.left
-            while root is None:
-                if len(stack) == 0:
-                    return res
-                root = stack.pop()
-                res.append(root.val)
-                root = root.right
+        stack = [root]
+        while len(stack) > 0:
+            curr = stack.pop()
+            if not isinstance(curr, TreeNode):
+                res.append(curr)
+                continue
+            if curr.right is not None:
+                stack.append(curr.right)
+            stack.append(curr.val)
+            if curr.left is not None:
+                stack.append(curr.left)
         return res
 
 
+