[Jeehay28] WEEK 15 Solutions

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

@@ -0,0 +1,44 @@
+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;
+  }
+}
+
+// TC: O(n)
+// SC: O(n)
+function buildTree(preorder: number[], inorder: number[]): TreeNode | null {
+  const indices = {};
+  //     indices = {
+  //   9: 0,
+  //   3: 1,
+  //   15: 2,
+  //   20: 3,
+  //   7: 4
+  // }
+
+  for (let i = 0; i < inorder.length; i++) {
+    const num = inorder[i];
+    indices[num] = i;
+  }
+
+  let preIndex = 0;
+
+  const dfs = (start: number, end: number) => {
+    if (start > end) return null;
+    const val = preorder[preIndex];
+    preIndex++;
+    const mid = indices[val];
+
+    const left = dfs(start, mid - 1);
+    const right = dfs(mid + 1, end);
+
+    return new TreeNode(val, left, right);
+  };
+
+  return dfs(0, inorder.length - 1);
+}

longest-palindromic-substring/Jeehay28.ts

@@ -0,0 +1,26 @@
+// TC: O(n^2)
+// SC: O(1)
+function longestPalindrome(s: string): string {
+  if (s.length < 2) return s;
+
+  let maxLeft = 0;
+  let maxRight = 0;
+
+  const expandWindow = (left: number, right: number): void => {
+    while (left >= 0 && right < s.length && s[left] === s[right]) {
+      if (maxRight - maxLeft < right - left) {
+        maxRight = right;
+        maxLeft = left;
+      }
+      left--;
+      right++;
+    }
+  };
+
+  for (let i = 0; i < s.length; i++) {
+    expandWindow(i, i); // odd length palindrome
+    expandWindow(i, i + 1); // even length palindrome
+  }
+
+  return s.slice(maxLeft, maxRight + 1);
+}

rotate-image/Jeehay28.ts

@@ -0,0 +1,26 @@
+/**
+ Do not return anything, modify matrix in-place instead.
+ */
+
+// TC: O(n^2)
+// SC: O(1)
+function rotate(matrix: number[][]): void {
+  let top = 0;
+  let bottom = matrix.length - 1;
+
+  while (top < bottom) {
+    let left = top;
+    let right = bottom;
+
+    for (let i = 0; i < bottom - top; i++) {
+      const temp = matrix[top][left + i]; // topLeft
+      matrix[top][left + i] = matrix[bottom - i][left];
+      matrix[bottom - i][left] = matrix[bottom][right - i];
+      matrix[bottom][right - i] = matrix[top + i][right];
+      matrix[top + i][right] = temp;
+    }
+
+    top++; // top down
+    bottom--; // bottom up
+  }
+}

subtree-of-another-tree/Jeehay28.ts

@@ -0,0 +1,29 @@
+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;
+  }
+}
+
+// TC: O(m + n), m = number of nodes in root, n = number of nodes in subRoot
+// SC: O(m + n)
+function isSubtree(root: TreeNode | null, subRoot: TreeNode | null): boolean {
+  const serializeNode = (node: TreeNode | null) => {
+    if (!node) return "$";
+
+    const str = `(${node.val},${serializeNode(node.left)},${serializeNode(
+      node.right
+    )})`;
+
+    return str;
+  };
+
+  const serializedRoot = serializeNode(root);
+  const serializedSubRoot = serializeNode(subRoot);
+
+  return serializedRoot.includes(serializedSubRoot);
+}