Week13 Solutions

Author: hoyeongkwak

find-median-from-data-stream/hoyeongkwak.ts

@@ -0,0 +1,43 @@
+class MedianFinder {
+    arr: number[]
+    constructor() {
+        this.arr = []
+    }
+    /*
+    Time Complexity: O(logn)
+    Space Complexity: O(n)
+    */
+    addNum(num: number): void {
+        let left = 0
+        let right = this.arr.length
+
+        while (left < right) {
+            const mid = Math.floor((left + right) / 2)
+            if (this.arr[mid] < num) {
+                left = mid + 1
+            } else {
+                right = mid
+            }
+        }
+        this.arr.splice(left, 0, num)
+    }
+    /*
+    Time Complexity: O(1)
+    Space Complexity: O(n)
+    */
+    findMedian(): number {
+        const n = this.arr.length
+        if (n % 2 === 0) {
+            return (this.arr[n / 2 - 1] + this.arr[n / 2]) / 2
+        } else {
+            return (this.arr[Math.floor(n / 2)])
+        }
+    }
+}
+
+/**
+ * Your MedianFinder object will be instantiated and called as such:
+ * var obj = new MedianFinder()
+ * obj.addNum(num)
+ * var param_2 = obj.findMedian()
+ */

insert-interval/hoyeongkwak.ts

@@ -0,0 +1,26 @@
+/*
+Time Complexity: O(n)
+Space Complexity: O(n)
+*/
+function insert(intervals: number[][], newInterval: number[]): number[][] {
+    const newIntervals = []
+    let idx = 0
+    const n = intervals.length
+    while (idx < n && intervals[idx][1] < newInterval[0]) {
+        newIntervals.push(intervals[idx])
+        idx++
+    }
+
+    while (idx < n && intervals[idx][0] <= newInterval[1]) {
+        newInterval[0] = Math.min(newInterval[0], intervals[idx][0])
+        newInterval[1] = Math.max(newInterval[1], intervals[idx][1])
+        idx++
+    }
+    newIntervals.push(newInterval)
+
+    while (idx < n) {
+        newIntervals.push(intervals[idx])
+        idx++
+    }
+    return newIntervals
+};

kth-smallest-element-in-a-bst/hoyeongkwak.ts

@@ -0,0 +1,34 @@
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
+/*
+Time Complexity: O(h + k)
+Space Complexity: O(h)
+*/
+function kthSmallest(root: TreeNode | null, k: number): number {
+    let count = 0
+    let result = -1
+    const inOrder = (node: TreeNode | null): void => {
+        if (node == null || count >= k) return
+
+        inOrder(node.left)
+        count++
+        if (count === k) {
+            result = node.val
+            return
+        }
+        inOrder(node.right)
+    }
+    inOrder(root)
+    return result
+};

lowest-common-ancestor-of-a-binary-search-tree/hoyeongkwak.ts

@@ -0,0 +1,31 @@
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
+/*
+Time Complexity: O(logn)
+Space Complexity: O(1)
+*/
+function lowestCommonAncestor(root: TreeNode | null, p: TreeNode | null, q: TreeNode | null): TreeNode | null {
+    if (!root || !p || !q) return null;
+	let node = root
+    while (node) {
+        if (p.val < node.val && q.val < node.val) {
+            node = node.left
+        } else if (p.val > node.val && q.val > node.val) {
+            node = node.right
+        } else {
+            return node
+        }
+    }
+    return null
+};