[jdy8739] week 13

kth-smallest-element-in-a-bst/jdy8739.js

@@ -0,0 +1,37 @@
+    /**
+ * 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
+ * @param {number} k
+ * @return {number}
+ */
+var kthSmallest = function(root, k) {
+    const arr = [];
+
+    const dfs = (node) => {
+        arr.push(node.val);
+
+        if (node?.left) {
+            dfs(node.left);
+        }
+
+        if (node?.right) {
+            dfs(node.right);
+        }
+    }
+
+    dfs(root);
+
+    const sort = arr.sort((a, b) => a - b);
+
+    return sort[k - 1];
+};
+
+// 시간복잡도 -> O(nlogn) dfs로 노드의 val을 배열에 넣고 정렬하는 시간이 소요됨
+// 공간복잡도 -> O(n) 리스트의 길이만큼 arr의 공간이 필요함

lowest-common-ancestor-of-a-binary-search-tree/jdy8739.js

@@ -0,0 +1,76 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode} p
+ * @param {TreeNode} q
+ * @return {TreeNode}
+ */
+var lowestCommonAncestor = function (root, p, q) {
+    const left = Math.min(p.val, q.val);
+    const right = Math.max(p.val, q.val);
+
+    const dfs = (node) => {
+        if (!node) {
+            return;
+        }
+
+        if (node.val >= left && node.val <= right) {
+            return node;
+        }
+
+        if (node.val > left && node.val > right) {
+            return dfs(node.left);
+        }
+
+        if (node.val < left && node.val < right) {
+            return dfs(node.right);
+        }
+    }
+
+    return dfs(root);
+};
+
+// 시간복잡도 O(logn) -> 이진트리를 이진탐색하면서 트리의 노드를 방문하기떄문(동일한 깊이에서 한 번 왼쪽을 방문하였다면, 그 깊이에서 오른쪽을 방문하지 않음)
+// 공간복잡도 O(h) -> 재귀호출을 사용하였으므로 트리의 높이만큼 최대 콜스택의 쌓임이 발생
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode} p
+ * @param {TreeNode} q
+ * @return {TreeNode}
+ */
+var lowestCommonAncestor = function (root, p, q) {
+    let node = root;
+
+    while (node) {
+        if (node.val >= p.val && node.val <= q.val) {
+            return node;
+        } else if (node.val < p.val && node.val < q.val) {
+            node = node.right;
+        } else if (node.val > p.val && node.val > q.val) {
+            node = node.left;
+        } else {
+            break;
+        }
+    }
+
+    return node;
+};
+
+// 시간복잡도 O(logn) -> 이진트리를 이진탐색하면서 트리의 노드를 방문하기떄문(동일한 깊이에서 한 번 왼쪽을 방문하였다면, 그 깊이에서 오른쪽을 방문하지 않음)
+// 공간복잡도 O(1) -> 알고리즘을 위해 요구되는 자료구조나 콜스택의 쌓임이 발생하지 않음

meeting-rooms/jdy8739.js

@@ -0,0 +1,44 @@
+import {
+  Interval,
+} from '/opt/node/lib/lintcode/index.js';
+
+/**
+ * Definition of Interval:
+ * class Interval {
+ *   constructor(start, end) {
+ *     this.start = start;
+ *     this.end = end;
+ *   }
+ * }
+ */
+
+export class Solution {
+  /**
+   * @param intervals: an array of meeting time intervals
+   * @return: if a person could attend all meetings
+   */
+  canAttendMeetings(intervals) {
+    const sort = intervals.sort((a, b) => {
+      if (a[1] === b[1]) {
+          return a[0] - b[0];
+      }
+
+      return a[1] - b[1];
+    })
+
+    for (let i = 0; i < sort.length - 2; i++) {
+      const current = sort[i][1];
+      const next = sort[i + 1][0];
+
+      if (current > next) {
+          return false;
+      }
+    }
+
+    return true;
+  }
+}
+
+// 시간복잡도 O(nlogn) -> sort 함수 사용으로 인한 시간복잡도
+// 공간복잡도 O(1) -> 사용하는 자료구조, 함수실행스택 없음
+