diff --git a/find-median-from-data-stream/yuseok89.py b/find-median-from-data-stream/yuseok89.py
new file mode 100644
index 0000000000..70cf0d84f1
--- /dev/null
+++ b/find-median-from-data-stream/yuseok89.py
@@ -0,0 +1,49 @@
+# TC (NlogN)
+# SC (N)
+class MedianFinder:
+
+    def __init__(self):
+        self.max_heap = []
+        self.min_heap = []
+
+    def addNum(self, num: int) -> None:
+        if len(self.min_heap) == 0 and len(self.max_heap) == 0:
+            heapq.heappush(self.min_heap, num)
+        elif len(self.max_heap) == 0:
+            mid = heapq.heappop(self.min_heap)
+            heapq.heappush(self.max_heap, -min(mid, num))
+            heapq.heappush(self.min_heap, max(mid, num))
+        elif len(self.max_heap) == len(self.min_heap):
+            mid1 = -self.max_heap[0]
+            mid2 = self.min_heap[0]
+
+            if num <= mid1:
+                heapq.heappush(self.max_heap, -num)
+            else:
+                heapq.heappush(self.min_heap, num)
+        else:
+            if len(self.max_heap) > len(self.min_heap):
+                mid = -heapq.heappop(self.max_heap)
+            else:
+                mid = heapq.heappop(self.min_heap)
+
+            heapq.heappush(self.max_heap, -min(mid, num))
+            heapq.heappush(self.min_heap, max(mid, num))
+
+    def findMedian(self) -> float:
+        if len(self.max_heap) == len(self.min_heap):
+            mid1 = -self.max_heap[0]
+            mid2 = self.min_heap[0]
+            return (mid1 + mid2) / 2.0
+        else:
+            if len(self.max_heap) > len(self.min_heap):
+                return float(-self.max_heap[0])
+            else:
+                return float(self.min_heap[0])
+
+
+# Your MedianFinder object will be instantiated and called as such:
+# obj = MedianFinder()
+# obj.addNum(num)
+# param_2 = obj.findMedian()
+
diff --git a/insert-interval/yuseok89.py b/insert-interval/yuseok89.py
new file mode 100644
index 0000000000..08c278fb89
--- /dev/null
+++ b/insert-interval/yuseok89.py
@@ -0,0 +1,24 @@
+#TC: O(N)
+#SC: O(N)
+class Solution:
+    def insert(self, intervals: list[list[int]], newInterval: list[int]) -> list[list[int]]:
+
+        ans = []
+        is_processed = False
+
+        for interval in intervals:
+            if is_processed or interval[1] < newInterval[0]:
+                ans.append(interval)
+            elif newInterval[1] < interval[0]:
+                ans.append(newInterval)
+                ans.append(interval)
+                is_processed = True
+            else:
+                newInterval[0] = min(newInterval[0], interval[0])
+                newInterval[1] = max(newInterval[1], interval[1])
+
+        if not ans or ans[-1][1] < newInterval[0]:
+            ans.append(newInterval)
+
+        return ans
+
diff --git a/kth-smallest-element-in-a-bst/yuseok89.py b/kth-smallest-element-in-a-bst/yuseok89.py
new file mode 100644
index 0000000000..71efa31e6d
--- /dev/null
+++ b/kth-smallest-element-in-a-bst/yuseok89.py
@@ -0,0 +1,32 @@
+# TC: O(N)
+# SC: O(H)
+# 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: TreeNode | None, k: int) -> int:
+
+        ans = 0
+
+        def rec(node: TreeNode | None) -> None:
+            nonlocal k, ans
+
+            if node is None or k <= 0:
+                return
+
+            rec(node.left)
+
+            k -= 1
+            if k == 0:
+                ans = node.val
+                return
+
+            rec(node.right)
+
+        rec(root)
+
+        return ans
+
diff --git a/lowest-common-ancestor-of-a-binary-search-tree/yuseok89.py b/lowest-common-ancestor-of-a-binary-search-tree/yuseok89.py
new file mode 100644
index 0000000000..ddb2b8ae59
--- /dev/null
+++ b/lowest-common-ancestor-of-a-binary-search-tree/yuseok89.py
@@ -0,0 +1,18 @@
+# TC: O(H)
+# SC: O(H)
+# 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 root.val < p.val and root.val < q.val:
+            return self.lowestCommonAncestor(root.right, p, q)
+        elif root.val > p.val and root.val > q.val:
+            return self.lowestCommonAncestor(root.left, p, q)
+        else:
+            return root
+