[bhyun-kim, 김병현] Week 8 Solutions

Author: bhyun-kim

construct-binary-tree-from-preorder-and-inorder-traversal/bhyun-kim.py

@@ -0,0 +1,60 @@
+"""
+105. Construct Binary Tree from Preorder and Inorder Traversal
+https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/
+"""
+
+from typing import List, Optional
+
+# 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
+
+"""
+Solution
+    To solve this problem, we can use a recursive approach. 
+    We can use a helper function that takes the left and right index of the inorder array.
+    The helper function will create a root node with the value of the current preorder index.
+    Then, it will recursively call itself with the left and right index of the left and right subtree.
+
+    - Create a dictionary that maps the value of the inorder array to its index.
+    - Create a variable to keep track of the current preorder index.
+    - Create a helper function that takes the left and right index of the inorder array.
+    - In the helper function, if the left index is greater than the right index, return None.
+    - Create a root node with the value of the current preorder index.
+    - Increment the preorder index.
+    - Recursively call the helper function with the left and right index of the left and right subtree.
+    - Return the root node.
+
+Time Complexity : O(n)
+    - The helper function is called n times.
+    - The dictionary lookup is O(1).
+
+Space Complexity : O(n)
+    - The dictionary has n elements.
+    - The recursive call stack has n elements.
+"""
+
+class Solution:
+    def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
+        inorder_index_map = {val: idx for idx, val in enumerate(inorder)}
+
+        self.preorder_index = 0
+
+        def array_to_tree(left, right):
+            if left > right:
+                return None
+
+            root_value = preorder[self.preorder_index]
+            self.preorder_index += 1
+
+            root = TreeNode(root_value)
+
+            root.left = array_to_tree(left, inorder_index_map[root_value] - 1)
+            root.right = array_to_tree(inorder_index_map[root_value] + 1, right)
+
+            return root
+
+        return array_to_tree(0, len(inorder) - 1)

implement-trie-prefix-tree/bhyun-kim.py

@@ -0,0 +1,47 @@
+"""
+208. Implement Trie (Prefix Tree)
+https://leetcode.com/problems/implement-trie-prefix-tree/
+
+Solution: 
+    - Initialize the Trie class with an empty list of words.
+    - Insert a word by appending it to the list of words.
+    - Search for a word by checking if it is in the list of words.
+    - Check if a prefix exists by iterating through the list of words and checking if any word starts with the prefix.
+
+Tiem complexity: 
+    - Insert: O(1)
+        - Appending to a list is O(1)
+    - Search: O(n)
+        - Searching for an element in a list is O(n)
+    - StartsWith: O(n)
+        - Iterating through a list is O(n)
+
+Space complexity: O(n)
+    - The list of words may have all the words in the trie.
+"""
+
+class Trie:
+
+    def __init__(self):
+        self.words = []
+
+    def insert(self, word: str) -> None:
+        self.words.append(word)
+        
+    def search(self, word: str) -> bool:
+        return word in self.words
+
+    def startsWith(self, prefix: str) -> bool:
+        for word in self.words:
+            if word.startswith(prefix):
+                return True
+
+        return False 
+        
+
+
+# Your Trie object will be instantiated and called as such:
+# obj = Trie()
+# obj.insert(word)
+# param_2 = obj.search(word)
+# param_3 = obj.startsWith(prefix)

kth-smallest-element-in-a-bst/bhyun-kim.py

@@ -0,0 +1,38 @@
+"""
+230. Kth Smallest Element in a BST
+https://leetcode.com/problems/kth-smallest-element-in-a-bst/
+
+Solution:
+    To solve this problem, we can use an in-order traversal of the binary search tree.
+    We can create a helper function that performs an in-order traversal of the tree and returns a list of the elements in sorted order.
+    Then, we can return the k-th element from the list.
+
+Time complexity: O(n)
+    - The in-order traversal visits each node once.
+    - The list concatenation is O(n).
+
+Space complexity: O(n)
+    - The list of elements has n elements.
+"""
+
+
+from typing import Optional
+
+# 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 kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
+        return self.inOrderSearch(root)[k-1]
+
+    def inOrderSearch(self, root):
+        output = []
+        if root: 
+            output += self.inOrderSearch(root.left)
+            output += [root.val]
+            output += self.inOrderSearch(root.right)
+        return output