[jdy8739] Week 11

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

@@ -0,0 +1,36 @@
+/**
+ * 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 max = root.val;
+
+    const dfs = (node) => {
+        if (!node) {
+            return 0;
+        }
+
+        const left = Math.max(dfs(node.left), 0);
+        const right = Math.max(dfs(node.right), 0);
+        const sum = node.val + left + right;
+
+        max = Math.max(sum, max);
+
+        return node.val + Math.max(left, right);
+    }
+
+    dfs(root);
+
+    return max;
+};
+
+// 시간복잡도 O(n) -> 트리의 모든 노드를 재귀적으로 탐색하므로 복잡도는 노드의 수와 비례함
+// 공간복잡도 O(h) -> 입력된 트리의 최대 높이만큼 재귀 스택이 쌓이므로 공간복잡도는 트리의 높이와 같음

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

@@ -0,0 +1,32 @@
+/**
+ * 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 max = 0;
+
+    const dfs = (node, depth) => {
+        if (node) {
+            dfs(node.left, depth + 1);
+            dfs(node.right, depth + 1);
+        } else { // when this node is null
+            max = Math.max(max, depth);
+        }
+    }
+
+    dfs(root, 0);
+
+    return max;
+};
+
+// 시간복잡도 O(n) -> 트리의 모든 노드를 방문하면서 총 노드의 갯수인 n개 만큼의 시간복잡도를 가지게 되므로
+// 공간복잡도 O(h) -> 콜스택의 최대 길이는 트리의 깊이와 동일하므로
+

merge-intervals/jdy8739.js

@@ -0,0 +1,29 @@
+/**
+ * @param {number[][]} intervals
+ * @return {number[][]}
+ */
+var merge = function (intervals) {
+    const sort = intervals.sort((a, b) => a[0] - b[0]);
+
+    const mergedIntervals = [sort[0]];
+
+    for (let i = 1; i < sort.length; i++) {
+        /** 현재 합쳐진 인터벌의 마지막 요소 */
+        const lastMergedInterval = mergedIntervals[mergedIntervals.length - 1];
+
+        const endOfMergedInterval = lastMergedInterval[1];
+
+        const next = sort[i][0];
+
+        if (endOfMergedInterval < next) {
+            mergedIntervals.push(sort[i]);
+        } else {
+            lastMergedInterval[1] = Math.max(lastMergedInterval[1], sort[i][1]);
+        }
+    }
+
+    return mergedIntervals;
+};
+
+// 시간복잡도 O(nlogn) -> sort 함수의 시간복잡도가 O(nlogn)이기 때문에
+// 공간복잡도 O(n) -> intervals 배열을 정렬하여 arr이라는 식별자의 배열을 만들어야 하기 때문에 필요한 공간

reorder-list/jdy8739.js

@@ -0,0 +1,54 @@
+/**
+ * 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) {
+    if (!head) {
+        return null;
+    }
+
+    const stack = [];
+
+    let node = head;
+
+    while (node) {
+        stack.push(node);
+        node = node.next;
+    }
+
+    const length = stack.length;
+
+    node = head;
+    let count = 0;
+
+    while (count < length) {
+        if (count % 2 === 0) {
+            const top = stack.pop();
+
+            top.next = node.next;
+
+            node.next = top;
+        }
+
+        if (count === length - 1) {
+            node.next = null;
+        } else {
+            node = node.next;
+        }
+
+        count++;
+    }
+
+
+    return head;
+};
+
+// 시간복잡도 O(n) -> while문이 링크드리스트의 길이만큼 순회를하기때문에 링크드리스트의 길이만큼 시간이 걸림
+// 공간복잡도 O(n) -> 스택에 모든 노드를 저장하기 때문에 링크드리스트의 길이만큼 공간이 필요