diff --git a/binary-tree-maximum-path-sum/gwbaik9717.js b/binary-tree-maximum-path-sum/gwbaik9717.js new file mode 100644 index 000000000..ac2aa925b --- /dev/null +++ b/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; +}; diff --git a/maximum-depth-of-binary-tree/gwbaik9717.js b/maximum-depth-of-binary-tree/gwbaik9717.js new file mode 100644 index 000000000..e0a47d850 --- /dev/null +++ b/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; +}; diff --git a/merge-intervals/gwbaik9717.js b/merge-intervals/gwbaik9717.js new file mode 100644 index 000000000..a65a32c19 --- /dev/null +++ b/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; +}; diff --git a/reorder-list/gwbaik9717.js b/reorder-list/gwbaik9717.js new file mode 100644 index 000000000..2076830a5 --- /dev/null +++ b/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; + } +};