Merge pull request #1928 from hyer0705/main

Author: hyer0705

binary-tree-maximum-path-sum/hyer0705.ts

@@ -0,0 +1,37 @@
+/**
+ * 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(n)
+// Space Complexity: O(h) where h is the height of the tree
+function maxPathSum(root: TreeNode | null): number {
+  let maximumSum = -Infinity;
+
+  const dfs = (node: TreeNode | null) => {
+    if (!node) return 0;
+
+    let leftResult = dfs(node.left);
+    let rightResult = dfs(node.right);
+
+    leftResult = Math.max(0, leftResult);
+    rightResult = Math.max(0, rightResult);
+
+    maximumSum = Math.max(maximumSum, node.val + leftResult + rightResult);
+
+    return node.val + Math.max(leftResult, rightResult);
+  };
+
+  dfs(root);
+
+  return maximumSum;
+}

graph-valid-tree/hyer0705.ts

@@ -0,0 +1,39 @@
+// Time Complexity: O(n)
+// Space Complexity: O(n)
+export class Solution {
+  /**
+   * @param n: An integer
+   * @param edges: a list of undirected edges
+   * @return: true if it's a valid tree, or false
+   */
+  validTree(n: number, edges: number[][]): boolean {
+    if (n === 0) return true;
+    if (edges.length !== n - 1) return false;
+
+    const graph: number[][] = Array.from({ length: n }, () => []);
+
+    for (const [s, e] of edges) {
+      graph[s].push(e);
+      graph[e].push(s);
+    }
+
+    const visited = new Set<number>();
+
+    const queue = [0];
+    visited.add(0);
+
+    let pointer = 0;
+    while (pointer < queue.length) {
+      const currentNode = queue[pointer++];
+
+      for (const nextNode of graph[currentNode]) {
+        if (!visited.has(nextNode)) {
+          queue.push(nextNode);
+          visited.add(nextNode);
+        }
+      }
+    }
+
+    return visited.size === n;
+  }
+}

merge-intervals/hyer0705.ts

@@ -0,0 +1,18 @@
+// Time Complexity: O(n log n)
+// Space Complexity: O(n)
+function merge(intervals: number[][]): number[][] {
+  const merged: number[][] = [];
+
+  intervals.sort((a, b) => a[0] - b[0]);
+
+  for (const [currentStart, currentEnd] of intervals) {
+    if (merged.length === 0 || merged[merged.length - 1][1] < currentStart) {
+      merged.push([currentStart, currentEnd]);
+    } else {
+      const lastMerged = merged[merged.length - 1];
+      lastMerged[1] = Math.max(lastMerged[1], currentEnd);
+    }
+  }
+
+  return merged;
+}

missing-number/hyer0705.ts

@@ -0,0 +1,22 @@
+// Time Complexity: O(n)
+// Space Complexity: O(1)
+function missingNumber(nums: number[]): number {
+  const n = nums.length;
+
+  const expectedSum = (n * (n + 1)) / 2;
+  const currentSum = nums.reduce((acc, curr) => acc + curr, 0);
+
+  return expectedSum - currentSum;
+}
+
+// Time Complexity: O(n^2)
+// Space Complexity: O(1)
+function missingNumber(nums: number[]): number {
+  const n = nums.length;
+
+  for (let i = 0; i <= n; i++) {
+    if (!nums.includes(i)) return i;
+  }
+
+  return -1;
+}

reorder-list/hyer0705.ts

@@ -0,0 +1,56 @@
+/**
+ * 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(1)
+/**
+ Do not return anything, modify head in-place instead.
+ */
+function reorderList(head: ListNode | null): void {
+  if (!head || !head.next || !head.next.next) return;
+
+  let slow: ListNode | null = head;
+  let fast: ListNode | null = head;
+
+  // find central node
+  while (fast && fast.next) {
+    slow = slow.next;
+    fast = fast.next.next;
+  }
+
+  let secondHalf = slow.next;
+  slow.next = null;
+
+  // reverse secondHalf
+  let prev = null;
+  let curr = secondHalf;
+  while (curr) {
+    const nextTemp = curr.next;
+    curr.next = prev;
+    prev = curr;
+    curr = nextTemp;
+  }
+
+  let first = head;
+  let second = prev;
+
+  while (second) {
+    const firstNext = first.next;
+    const secondNext = second.next;
+
+    first.next = second;
+    second.next = firstNext;
+
+    first = firstNext;
+    second = secondNext;
+  }
+}