solve two problems BST

07 BINARY SEARCH TREE/README.md

@@ -126,38 +126,75 @@ Time complexity: O(n), n = number of node
 
 traversal: LEFT -> ROOT -> RIGHT
 ```python
+# Space Complexity: O(1), print out the result line by line
+
 def inorder_traverse(root):
     if root is not None:
         inorder_traverse(root.left)
         print(root.value)
         inorder_traverse(root.right)
 ```
+
+```python
+# Space Complexity: O(n), return the result in the array
+
+def inorder_traverse(root):
+    if root is None: return []
+    left = self.inorderTraversal(root.left)
+    right = self.inorderTraversal(root.right)
+    return left + [root.val] + right
+```
 ### Preorder traversal
 
 Time complexity: O(n), n = number of node
 
 traversal: ROOT -> LEFT -> RIGHT
 ```python
+# Space Complexity: O(1), print out the result line by line
+
 def preorder_traverse(root):
     if root is not None:
         print(root.value)
         preorder_traverse(root.left)
         preorder_traverse(root.right)
 ```
 
+```python
+# Space Complexity: O(n), return the result in the array
+
+def preorder_traverse(root):
+    if root is None: return []
+    left = self.inorderTraversal(root.left)
+    right = self.inorderTraversal(root.right)
+    return [root.val] + left + right
+```
+
+
 ### Postorder traversal
 
 Time complexity: O(n), n = number of node
 
 traversal: LEFT -> RIGHT -> ROOT
 ```python
+# Space Complexity: O(1), print out the result line by line
+
 def postorder_traverse(root):
     if root is not None:
         preorder_traverse(root.left)
         preorder_traverse(root.right)
         print(root.value)
 ```
 
+```python
+# Space Complexity: O(n), return the result in the array
+
+def postorder_traverse(root):
+    if root is None: return []
+    left = self.inorderTraversal(root.left)
+    right = self.inorderTraversal(root.right)
+    return left + right + [root.val]
+```
+
 ## Height of BST
 
 Time complexity: O(n)
@@ -174,7 +211,7 @@ def height_tree(root):
     else:
         left_h = height_tree(root.left)
         right_h = height_tree(root.right)
-        max_h = left_h < right_h and right_h or left_h
+        max_h = max(left_h, right_h)
         return max_h + 1
 ```
 ```python
@@ -185,7 +222,7 @@ def height_tree(root):
     else:
         left_h = height_tree(root.left)
         right_h = height_tree(root.right)
-        max_h = left_h < right_h and right_h or left_h
+        max_h = max(left_h, right_h)
         return max_h + 1
 ```
 
@@ -202,3 +239,9 @@ def delete_tree(root):
         delete_tree(root.right)
         del root
 ```
+
+## Practice
+
+[Binary Tree Inorder Traversal](https://github.com/nghoanglong/DataStructures-Algorithms-CheatSheet/blob/master/06%20BINARY%20SEARCH/search_in_rst.py)
+
+[Maximum Depth of Binary Tree](https://github.com/nghoanglong/DataStructures-Algorithms-CheatSheet/blob/master/06%20BINARY%20SEARCH/search_ins_position.py)

07 BINARY SEARCH TREE/inorder_traversal.py

@@ -0,0 +1,21 @@
+# Link: https://leetcode.com/problems/binary-tree-inorder-traversal/
+# Site: LeetCode
+# Name: Binary Tree Inorder Traversal
+# Easy
+# ======================================================
+
+# Time Complexity: O(n)
+# Space Complexity: O(n)
+
+# 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 inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
+        if root is None: return []
+        left = self.inorderTraversal(root.left)
+        right = self.inorderTraversal(root.right)
+        return left + [root.val] + right

07 BINARY SEARCH TREE/maximum_depth.py

@@ -0,0 +1,24 @@
+# Link: https://leetcode.com/problems/maximum-depth-of-binary-tree/
+# Site: LeetCode
+# Name: Maximum Depth of Binary Tree
+# Easy
+# ======================================================
+
+# Time Complexity: O(n)
+# Space Complexity: O(1)
+
+# 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 maxDepth(self, root: Optional[TreeNode]) -> int:
+        if root is None: return 0
+        else:
+            left_height = self.maxDepth(root.left)
+            right_height = self.maxDepth(root.right)
+            max_height = max(left_height, right_height)
+            return 1 + max_height
+