Merge pull request #1029 from gwbaik9717/main

[ganu] Week11

Author: gwbaik9717

binary-tree-maximum-path-sum/gwbaik9717.js

@@ -0,0 +1,47 @@
+// Time complexity: O(n)
+// Space complexity: O(n)
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var maxPathSum = function (root) {
+  let answer = Number.MIN_SAFE_INTEGER;
+
+  const dfs = (current) => {
+    const candidates = [current.val];
+
+    if (current.left) {
+      dfs(current.left);
+      candidates.push(current.left.val + current.val);
+    }
+
+    if (current.right) {
+      dfs(current.right);
+      candidates.push(current.right.val + current.val);
+    }
+
+    // 현재 노드가 루트일 경우
+    if (current.left && current.right) {
+      answer = Math.max(
+        answer,
+        current.left.val + current.right.val + current.val
+      );
+    }
+
+    current.val = Math.max(...candidates);
+    answer = Math.max(answer, current.val);
+  };
+
+  dfs(root);
+
+  return answer;
+};

maximum-depth-of-binary-tree/gwbaik9717.js

@@ -0,0 +1,39 @@
+// Time complexity: O(n)
+// Space complexity: O(n)
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var maxDepth = function (root) {
+  let answer = 0;
+
+  const dfs = (current, depth) => {
+    if (!current) {
+      return;
+    }
+
+    if (answer < depth) {
+      answer = depth;
+    }
+
+    if (current.left) {
+      dfs(current.left, depth + 1);
+    }
+
+    if (current.right) {
+      dfs(current.right, depth + 1);
+    }
+  };
+
+  dfs(root, 1);
+  return answer;
+};

merge-intervals/gwbaik9717.js

@@ -0,0 +1,33 @@
+// Time complexity: O(nlogn)
+// Space complexity: O(n)
+
+/**
+ * @param {number[][]} intervals
+ * @return {number[][]}
+ */
+var merge = function (intervals) {
+  intervals.sort((a, b) => {
+    if (a[0] === b[0]) {
+      return a[1] - b[1];
+    }
+
+    return a[0] - b[0];
+  });
+
+  const answer = [intervals[0]];
+
+  for (let i = 1; i < intervals.length; i++) {
+    const current = intervals.at(i);
+    const prev = answer.at(-1);
+
+    // No overlapping
+    if (current[0] > prev[1]) {
+      answer.push(current);
+      continue;
+    }
+
+    answer[answer.length - 1] = [prev[0], Math.max(prev[1], current[1])];
+  }
+
+  return answer;
+};

reorder-list/gwbaik9717.js

@@ -0,0 +1,56 @@
+// Time complexity: O(n)
+// Space complexity: O(1)
+
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {void} Do not return anything, modify head in-place instead.
+ */
+var reorderList = function (head) {
+  // middle 찾기
+  let slow = head;
+  let fast = slow;
+
+  while (fast && fast.next) {
+    fast = fast.next.next;
+    slow = slow.next;
+  }
+
+  const middle = slow;
+
+  // 후반부 뒤집기 (middle 부터)
+  let next = null;
+  let current = middle;
+
+  while (current) {
+    const temp = current.next;
+    current.next = next;
+    next = current;
+    current = temp;
+  }
+
+  // 합치기
+  let back = next;
+  let reordered = head;
+
+  while (reordered && back) {
+    const temp = reordered.next;
+
+    reordered.next = back;
+    back = back.next;
+    reordered = reordered.next;
+
+    reordered.next = temp;
+    reordered = reordered.next;
+  }
+
+  if (reordered) {
+    reordered.next = null;
+  }
+};