Merge pull request #128 from SamTheKorean/solution7

[SAM] Week 7 solutions

Author: SamTheKorean

binary-tree-level-order-traversal/samthekorean.py

@@ -0,0 +1,24 @@
+# TC : O(n)
+# SC : O(n)
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        q = collections.deque()
+        res = []
+        q.append(root)
+
+        while q:
+            level = []
+            qLen = len(q)
+
+            # traverse nodes in each level and append left and right subtree if node is None
+            for i in range(qLen):
+                node = q.popleft()
+                if node:
+                    level.append(node.val)
+                    # append the subtrees of q for the next level in advance
+                    q.append(node.left)
+                    q.append(node.right)
+            if level:
+                res.append(level)
+
+        return res

lowest-common-ancestor-of-a-binary-search-tree/samthekorean.py

@@ -0,0 +1,16 @@
+# TC : O(log n) because its a balanced tree
+# SC : O(1)
+class Solution:
+    def lowestCommonAncestor(
+        self, root: "TreeNode", p: "TreeNode", q: "TreeNode"
+    ) -> "TreeNode":
+        current = root
+
+        # Return when they split to left and right
+        while current:
+            if p.val > current.val and q.val > current.val:
+                current = current.right
+            elif p.val < current.val and q.val < current.val:
+                current = current.left
+            else:
+                return current

remove-nth-node-from-end-of-list/samthekorean.py

@@ -0,0 +1,23 @@
+# TC : O(n)
+# SC : O(1)
+class Solution:
+    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
+        # Create a dummy node to handle edge cases such as removing the first node
+        dummy = ListNode(0, head)
+        left = dummy
+        right = head
+
+        # Move the right pointer n steps ahead
+        for _ in range(n):
+            right = right.next
+
+        # Move both pointers until right reaches the end
+        while right:
+            left = left.next
+            right = right.next
+
+        # Remove the nth node from the end
+        left.next = left.next.next
+
+        # Return the head of the modified list
+        return dummy.next

reorder-list/samthekorean.py

@@ -0,0 +1,32 @@
+# TC : O(n)
+# SC : O(m) m being the sum of deque and dummy nodes
+class Solution:
+    def reorderList(self, head: Optional[ListNode]) -> None:
+        if not head or not head.next or not head.next.next:
+            return
+
+        # Step 1: Use a deque to collect nodes
+        d = deque()
+        current = head
+        while current:
+            d.append(current)
+            current = current.next
+
+        # Step 2: Reorder the list using deque
+        dummy = ListNode(0)  # Dummy node with value 0
+        current = dummy
+        toggle = True
+
+        while d:
+            if toggle:
+                current.next = d.popleft()  # Append from the front of the deque
+            else:
+                current.next = d.pop()  # Append from the back of the deque
+            current = current.next
+            toggle = not toggle
+
+        # Step 3: Ensure the last node points to None
+        current.next = None
+
+        # Step 4: Reassign head to point to the new reordered list
+        head = dummy.next

validate-binary-search-tree/samthekorean.py

@@ -0,0 +1,16 @@
+# TC : O(n) where n being the number of nodes of the tree
+# SC : O(n) where n being the size of sum of every nodes
+class Solution:
+    def isValidBST(self, root: Optional[TreeNode]) -> bool:
+        def is_valid_bst(node, min_val, max_val):
+            if not node:
+                return True
+
+            if node.val <= min_val or node.val >= max_val:
+                return False
+
+            return is_valid_bst(node.left, min_val, node.val) and is_valid_bst(
+                node.right, node.val, max_val
+            )
+
+        return is_valid_bst(root, float("-inf"), float("inf"))