Merge remote-tracking branch 'origin/main'

Author: radiantchoi

find-median-from-data-stream/8804who.py

@@ -0,0 +1,26 @@
+import heapq
+
+class MedianFinder:
+
+    def __init__(self):
+        self.max_heap = []
+        self.min_heap = []
+
+    def addNum(self, num: int) -> None:
+        if not self.min_heap or self.min_heap[0] <= num:
+            heapq.heappush(self.min_heap, num)
+        else:
+            heapq.heappush(self.max_heap, -num)
+        
+        if len(self.min_heap) < len(self.max_heap):
+            heapq.heappush(self.min_heap, -heapq.heappop(self.max_heap))
+        elif len(self.min_heap) > len(self.max_heap) + 1:
+            heapq.heappush(self.max_heap, -heapq.heappop(self.min_heap))
+
+    def findMedian(self) -> float:
+        if len(self.min_heap) == len(self.max_heap):
+            return (self.min_heap[0]-self.max_heap[0])/2
+        else:
+            return self.min_heap[0]
+        
+    

insert-interval/8804who.py

@@ -0,0 +1,20 @@
+class Solution:
+    def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]:
+        new_start = 1e9
+        new_end = -1
+
+        answer = []
+
+        for start, end in intervals:
+            if start <= newInterval[0] <= end or newInterval[0] <= start <= newInterval[1] or newInterval[0] <= end <= newInterval[1] or start <= newInterval[1] <= end:
+                if new_start == 1e9:
+                    new_start = start
+                new_end = end
+            else:
+                answer.append([start, end])
+        new_start = min(new_start, newInterval[0])
+        new_end = max(new_end, newInterval[1])
+        
+        answer.append([new_start, new_end])
+        return sorted(answer)
+    

insert-interval/Seoya0512.py

@@ -0,0 +1,26 @@
+'''
+Time Complexity : O(N)
+- newInterval을 삽입할 위치 탐색 O(N)
+- Intervals 병합을 위해 for문으로 모든 구간을 순회 O(N)
+- O(N) + O(N) = O(N)
+
+Space Complexity : O(N)
+- output 리스트에 모든 구간을 저장 O(N)
+
+'''
+class Solution:
+    def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]:
+        idx = 0
+        while idx < len(intervals) and intervals[idx][0] < newInterval[0]:
+            idx +=1
+        intervals.insert(idx, newInterval)    # newInterval을 삽입할 위치 탐색 (O(N))
+
+        # Intervals 병합
+        output = [intervals[0]]
+        for interval in intervals[1:]:
+            # 이전 구간과 겹치는 경우
+            if output[-1][1] >= interval[0]:
+                output[-1][1] = max(output[-1][1], interval[1])
+            else:
+                output.append(interval)
+        return output

insert-interval/ppxyn1.py

@@ -0,0 +1,32 @@
+# idea: - 
+# Time Complexity: O(n)
+class Solution:
+    def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]:
+        res = []
+
+        # Ex,. newInterval = [2,5]
+        for i in range(len(intervals)):
+            start, end = intervals[i] 
+
+            # [2,5] > [1,5] 
+
+            # already passed
+            if end < newInterval[0]: 
+                res.append(intervals[i])
+
+            # not started yet
+            # (2)
+            elif newInterval[1] < start: 
+                res.append(newInterval) # [1,5]
+                for j in range(i, len(intervals)):
+                    res.append(intervals[j])
+                return res
+            else:
+                # (1)
+                # overlapping
+                newInterval[0] = min(newInterval[0], start)
+                newInterval[1] = max(newInterval[1], end)
+
+        res.append(newInterval)
+        return res
+

kth-smallest-element-in-a-bst/8804who.py

@@ -0,0 +1,25 @@
+# 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:
+        answer = 0
+
+        def dfs(node):
+            nonlocal k
+            nonlocal answer
+            if node.left:
+                dfs(node.left)
+            k -= 1
+            if k == 0:
+                answer = node.val
+                return
+            if node.right:
+                dfs(node.right)
+        dfs(root)
+
+        return answer
+    

kth-smallest-element-in-a-bst/Seoya0512.py

@@ -0,0 +1,29 @@
+'''
+Time Complexity: O(N)
+- dfs 함수가 모든 노드를 중위순회 방식으로 방문함므로 O(N) 소요
+
+Space Complexity: O(N)
+- aligned_arr 리스트에 모든 노드의 값을 저장하므로 O(N) 소요
+- 재귀 호출 스택이 최대 트리의 높이만큼 쌓일 수 있으므로 최악의 경우 O(N) 소요
+'''
+
+# 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:
+        aligned_arr = []
+
+        def dfs(node):
+            if not node:
+                return
+            dfs(node.left)
+            aligned_arr.append(node.val)
+            dfs(node.right)
+        
+        dfs(root)
+
+        return aligned_arr[k - 1]

kth-smallest-element-in-a-bst/ppxyn1.py

@@ -0,0 +1,30 @@
+# 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
+
+#idea : DFS (inorder)
+#Time Complexity: O(n)
+
+class Solution:
+    def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
+        stack = []
+        cnt = 0
+        curr = root 
+        if not curr:
+            return
+
+        while curr or stack:
+            while curr:
+                stack.append(curr)
+                curr = curr.left 
+            curr = stack.pop()
+            cnt += 1
+
+            if cnt == k:
+                return curr.val
+            
+            curr = curr.right 
+

kth-smallest-element-in-a-bst/ys-han00.cpp

@@ -0,0 +1,29 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    vector<int> values;
+
+    void dfs(TreeNode* node) {
+        if(node == nullptr)
+            return;
+        dfs(node->left);
+        values.push_back(node->val);
+        dfs(node->right);
+    }
+
+    int kthSmallest(TreeNode* root, int k) {
+        dfs(root);
+        return values[k - 1];
+    }
+};
+

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

@@ -0,0 +1,15 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution:
+    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
+        if p.val < root.val and  q.val < root.val:
+            return self.lowestCommonAncestor(root.left, p, q)
+        if p.val > root.val and q.val > root.val:
+            return self.lowestCommonAncestor(root.right, p, q)
+        return root
+    

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

@@ -0,0 +1,12 @@
+'''
+Time Complexity: O(H)
+- H는 트리의 높이
+'''
+
+class Solution:
+    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
+        if p.val < root.val and q.val < root.val:
+            return self.lowestCommonAncestor(root.left, p, q)
+        if p.val > root.val and q.val > root.val:
+            return self.lowestCommonAncestor(root.right, p, q)
+        return root