[hoyeongkwak] Week 12 Solutions

non-overlapping-intervals/hoyeongkwak.ts

@@ -0,0 +1,17 @@
+/*
+Time complexity: O(nlogn)
+Space complexity: O(n)
+*/
+function eraseOverlapIntervals(intervals: number[][]): number {
+    intervals.sort((a, b) => a[1] - b[1])
+    let cnt = 0
+    let end = intervals[0][1]
+    for (let i = 1; i < intervals.length; i++) {
+        if (intervals[i][0] < end) {
+            cnt++
+        } else {
+            end = intervals[i][1]
+        }
+    }
+    return cnt
+};

remove-nth-node-from-end-of-list/hoyeongkwak.ts

@@ -0,0 +1,32 @@
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     val: number
+ *     next: ListNode | null
+ *     constructor(val?: number, next?: ListNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.next = (next===undefined ? null : next)
+ *     }
+ * }
+ */
+/*
+Time complexity: O(n)
+Space complexity: O(h)
+*/
+function removeNthFromEnd(head: ListNode | null, n: number): ListNode | null {
+    if (head == null) return head
+    const listLength = (node: ListNode | null): number => {
+        if (node == null) return 0
+        return 1 + listLength(node.next)
+    }
+    const nodeLen = listLength(head)
+    let dummy: ListNode = new ListNode(0, head);
+    let node = dummy
+    for (let i = 0; i < nodeLen - n; i++) {
+        if (node.next) {
+            node = node.next
+        }
+    }
+    node.next = node.next.next
+    return dummy.next
+};

same-tree/hoyeongkwak.ts

@@ -0,0 +1,23 @@
+/**
+ * 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(m)
+Space complexity: O(h)
+*/
+function isSameTree(p: TreeNode | null, q: TreeNode | null): boolean {
+    if (p == null && q == null) return true
+    if (p == null || q == null) return false
+    if (p.val !== q.val) return false
+    return isSameTree(p.left, q.left) && isSameTree(p.right, q.right)    
+};

serialize-and-deserialize-binary-tree/hoyeongkwak.ts

@@ -0,0 +1,67 @@
+/**
+ * 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)
+ *     }
+ * }
+ */
+
+/*
+ * Encodes a tree to a single string.
+ */
+function serialize(root: TreeNode | null): string {
+    /*
+    Time complexity: O(n)
+    Space complexity: O(n)
+    */
+    const strArray = []
+    const dfs = (node: TreeNode): void => {
+        if (node == null) {
+            strArray.push('null')
+            return
+        }
+        strArray.push(node.val)
+        dfs(node.left)
+        dfs(node.right)
+    }
+    dfs(root)
+    return strArray.join(',')
+};
+
+/*
+ * Decodes your encoded data to tree.
+ */
+function deserialize(data: string): TreeNode | null {
+     /*
+    Time complexity: O(n)
+    Space complexity: O(n)
+    */
+    const values = data.split(',')
+    let idx = 0
+    const dfs = (): TreeNode | null => {
+        if (idx >= values.length || values[idx] == 'null') {
+            idx++
+            return null
+        }
+        const node = new TreeNode(+values[idx])
+        idx++
+        node.left = dfs()
+        node.right = dfs()
+        return node
+    }
+
+    return dfs()
+};
+
+
+/**
+ * Your functions will be called as such:
+ * deserialize(serialize(root));
+ */
+