update solution: insert-interval

Author: dusunax

insert-interval/dusunax.py

@@ -1,29 +1,23 @@
 '''
 # 57. Insert Interval
 
-use binary search to find the index of the new interval.(bisect_left)
-insert the new interval into the list.
-iterate through the list and merge the intervals.
+## A. insert first, merge later
+- use binary search to find the index of the new interval.(bisect_left)
+- insert the new interval into the list.
+- iterate through the list and merge the intervals.
 
-=> insert first, merge later
-
-## Time and Space Complexity
-
-```
-TC: O(n)
-SC: O(n)
-```
-
-#### TC is O(n):
-- do binary search to find correct index of the new interval. = O(log n)
-- inserting the new interval into the list. = O(n)
-- iterating through the list to merge the intervals. = O(n)
-
-#### SC is O(n):
-- using a list to store the intervals. = O(n)
+## B. insert, merge, insert
+- inserting the intervals into the result list until finding the correct index of the new interval.
+- merge the overlapping intervals than insert the newInterval into the result list.
+- insert the remaining intervals into the result list.
 '''
 class Solution:
-    def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]:
+    '''
+    # A. insert first, merge later
+    - TC: O(n)
+    - SC: O(n)
+    '''
+    def insertUsingBisectLeftToFindIndex(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]:
         start_idx = bisect_left([interval[0] for interval in intervals], newInterval[0]) # TC: O(log n)
 
         intervals.insert(start_idx, newInterval) # TC: O(n)
@@ -36,3 +30,31 @@ def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[Lis
                 result[-1][1] = max(result[-1][1], interval[1])
 
         return result
+    
+    '''
+    # B. insert, merge, insert
+    - TC: O(n)
+    - SC: O(n)
+    '''
+    def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]:
+        result = [] # SC: O(n)
+        i = 0
+        n = len(intervals)
+
+        # 1. insert until finding the correct index of newInterval
+        while i < n and intervals[i][1] < newInterval[0]: # TC: O(n)
+            result.append(intervals[i])
+            i += 1
+
+        # merge overapping intervals & insert newInterval
+        while i < n and intervals[i][0] <= newInterval[1]: # TC: O(n)
+            newInterval[0] = min(newInterval[0], intervals[i][0])
+            newInterval[1] = max(newInterval[1], intervals[i][1])
+            i += 1
+        result.append(newInterval)
+        
+        while i < n: # TC: O(n)
+            result.append(intervals[i])
+            i += 1
+        
+        return result