Merge pull request #1665 from hoyeongkwak/main

[hoyeongkwak] Week15 Solutions

Author: hoyeongkwak

construct-binary-tree-from-preorder-and-inorder-traversal/hoyeongkwak.ts

@@ -0,0 +1,52 @@
+/**
+ * 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)
+ *     }
+ * }
+ */
+
+function buildTree(preorder: number[], inorder: number[]): TreeNode | null {
+    if (preorder == null || inorder == null || preorder.length === 0 || inorder.length === 0) {
+        return null
+    } 
+
+    const inorderMap = new Map()
+    for (let i = 0 ; i < inorder.length; i++) {
+        inorderMap.set(inorder[i], i)
+    }
+
+    const build = (preStart, preEnd, inStart, inEnd): TreeNode => {
+        if (preStart > preEnd || inStart > inEnd) {
+            return null
+        }
+
+        const rootVal = preorder[preStart]
+        const root = new TreeNode(rootVal)
+
+        const rootIndex = inorderMap.get(rootVal)
+        const leftSize = rootIndex - inStart
+
+        root.left = build(
+            preStart + 1,
+            preStart + leftSize,
+            inStart,
+            rootIndex - 1
+        )
+
+        root.right = build(
+            preStart + leftSize + 1,
+            preEnd,
+            rootIndex + 1,
+            inEnd
+        )
+        return root
+    }
+    return build(0, preorder.length - 1, 0, inorder.length - 1)
+};

longest-palindromic-substring/hoyeongkwak.ts

@@ -0,0 +1,31 @@
+function longestPalindrome(s: string): string {
+    if (s.length < 2) {
+        return s
+    }
+    let maxStart = 0
+    let maxEnd = 0
+    for (let i = 0 ; i < s.length; i++) {
+        let start = i
+        let end = i
+        while (0 <= start && end < s.length && s[start] === s[end]) {
+            if (end - start > maxEnd - maxStart) {
+                maxStart = start
+                maxEnd = end
+            }
+            start--
+            end++
+        }
+
+        start = i
+        end = i + 1
+        while (0 <= start && end <s.length && s[start] === s[end]) {
+            if (end - start > maxEnd - maxStart) {
+                maxStart = start 
+                maxEnd = end
+            }
+            start--
+            end++
+        }
+    }
+    return s.slice(maxStart, maxEnd + 1)
+};

rotate-image/hoyeongkwak.ts

@@ -0,0 +1,31 @@
+function longestPalindrome(s: string): string {
+    if (s.length < 2) {
+        return s
+    }
+    let maxStart = 0
+    let maxEnd = 0
+    for (let i = 0 ; i < s.length; i++) {
+        let start = i
+        let end = i
+        while (0 <= start && end < s.length && s[start] === s[end]) {
+            if (end - start > maxEnd - maxStart) {
+                maxStart = start
+                maxEnd = end
+            }
+            start--
+            end++
+        }
+
+        start = i
+        end = i + 1
+        while (0 <= start && end <s.length && s[start] === s[end]) {
+            if (end - start > maxEnd - maxStart) {
+                maxStart = start 
+                maxEnd = end
+            }
+            start--
+            end++
+        }
+    }
+    return s.slice(maxStart, maxEnd + 1)
+};

subtree-of-another-tree/hoyeongkwak.ts

@@ -0,0 +1,27 @@
+/**
+ * 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)
+ *     }
+ * }
+ */
+
+function isSubtree(root: TreeNode | null, subRoot: TreeNode | null): boolean {
+    if (!subRoot) return true
+    if (!root) return false
+
+    const isSameTree = (p, q): boolean => {
+        if (!(p && q)) return p === q
+        if (p.val !== q.val) return false
+        return isSameTree(p.left, q.left) && isSameTree(p.right, q.right)
+    }
+
+    if (isSameTree(root, subRoot)) return true
+    return isSubtree(root.left, subRoot) || isSubtree(root.right, subRoot)
+};