Merge pull request #1038 from pmjuu/main

[Lyla] Week 11

Author: TonyKim9401

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

@@ -0,0 +1,22 @@
+'''
+시간 복잡도: O(n)
+공간 복잡도: O(n)
+'''
+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 maxDepth(self, root: Optional[TreeNode]) -> int:
+        if not root:
+            return 0
+        
+        left = self.maxDepth(root.left)
+        right = self.maxDepth(root.right)
+
+        return max(left, right) + 1

merge-intervals/pmjuu.py

@@ -0,0 +1,28 @@
+'''
+시간 복잡도: O(n log n)
+- intervals 정렬하는 데 O(n log n)
+- intervals 한 번 순회하면서 병합 작업 수행: O(n)
+
+공간 복잡도: O(n)
+- 결과 리스트에 병합된 interval을 저장해야 하므로 O(n)
+'''
+from typing import List
+
+class Solution:
+    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
+        result = []
+        intervals.sort(key=lambda x: x[0])
+        left, right = intervals[0]
+
+        for start, end in intervals[1:]:
+            # stop merging
+            if 0 <= right < start:
+                result.append([left, right])
+                left, right = start, end
+            # merge overlapping intervals
+            else:
+                left, right = min(left, start), max(right, end)
+
+        result.append([left, right])
+        
+        return result

reorder-list/pmjuu.py

@@ -0,0 +1,37 @@
+'''
+시간 복잡도: O(n)
+- 중간 노드 찾기: O(n)
+- 리스트 반전: O(n)
+- 리스트 병합: O(n)
+
+공간 복잡도: O(1)
+- 포인터만 사용하여 링크를 조작하므로 O(1)
+'''
+from typing import Optional
+# Definition for singly-linked list.
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+        
+class Solution:
+    def reorderList(self, head: Optional[ListNode]) -> None:
+        """
+        Do not return anything, modify head in-place instead.
+        """
+        # find the middle node
+        slow, fast = head, head
+        while fast and fast.next:
+            slow = slow.next
+            fast = fast.next.next
+
+        # reverse back half of the list
+        prev, curr = None, slow.next
+        slow.next = None # cut in the middle
+        while curr:
+            curr.next, prev, curr = prev, curr, curr.next
+
+        # merge front half with back half
+        first, second = head, prev
+        while second:
+            first.next, second.next, first, second = second, first.next, first.next, second.next