[dolphinflow86] WEEK 04 Solutions

find-minimum-in-rotated-sorted-array/dolphinflow86.py

@@ -0,0 +1,20 @@
+# 1) Use binary search to halves to search range. Each iteration, 
+# compare with nums[pivot] and nums[right] to see which side has a smaller range. 
+# Firstly I compare nums[left] with nums[right] so I got the wrong results but end up with the right solution.
+# TC: O(logN) where N is the length of the nums array
+# SC: O(1)
+
+class Solution:
+    def findMin(self, nums: List[int]) -> int:
+        n = len(nums)
+        left = 0
+        right = n-1
+
+        while left < right:
+            pivot = left + (right - left) // 2
+            if nums[pivot] < nums[right]:
+                right = pivot
+            else:
+                left = pivot + 1
+
+        return nums[right]

maximum-depth-of-binary-tree/dolphinflow86.py

@@ -0,0 +1,20 @@
+# 1) Use DFS to traverse down to the leaf node. Keep track of depth and return each node's maximum depth of each subtree to the parent node.
+# TC: O(N) where N is the number of node in the binary tree
+# SC: O(H) where H is the height of the binary tree
+# 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 dfs(self, node: Optional[TreeNode], depth: int) -> int:
+        if not node:
+            return depth
+
+        left = self.dfs(node.left, depth + 1)
+        right = self.dfs(node.right, depth + 1)
+        return max(left, right)
+
+    def maxDepth(self, root: Optional[TreeNode]) -> int:
+        return self.dfs(root, 0)

merge-two-sorted-lists/dolphinflow86.py

@@ -0,0 +1,27 @@
+# 1) Use a dummy node and connect the smaller node to the merged list while iterating through both lists.
+# TC: O(N + M) where N is the length of list1 and M is the length of list2.
+# SC: O(1)
+#
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+
+class Solution:
+    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
+        dummy = ListNode()
+        curr = dummy
+
+        while list1 and list2:
+            if list1.val < list2.val:
+                curr.next = list1
+                list1 = list1.next
+            else:
+                curr.next = list2
+                list2 = list2.next
+            curr = curr.next
+
+        curr.next = list1 if list1 else list2
+
+        return dummy.next