week13 solved

Author: hsskey

find-median-from-data-stream/hsskey.js

@@ -0,0 +1,103 @@
+class Heap {
+    constructor(compare) {
+      this.data = [];
+      this.compare = compare;
+    }
+  
+    size() {
+      return this.data.length;
+    }
+  
+    peek() {
+      return this.data[0];
+    }
+  
+    push(val) {
+      this.data.push(val);
+      this._siftUp();
+    }
+  
+    pop() {
+      const top = this.peek();
+      const bottom = this.data.pop();
+      if (this.data.length > 0) {
+        this.data[0] = bottom;
+        this._siftDown();
+      }
+      return top;
+    }
+  
+    _siftUp() {
+      let i = this.data.length - 1;
+      const node = this.data[i];
+      while (i > 0) {
+        const parent = Math.floor((i - 1) / 2);
+        if (this.compare(node, this.data[parent])) {
+          this.data[i] = this.data[parent];
+          i = parent;
+        } else break;
+      }
+      this.data[i] = node;
+    }
+  
+    _siftDown() {
+      let i = 0;
+      const node = this.data[0];
+      const length = this.data.length;
+  
+      while (true) {
+        let left = 2 * i + 1;
+        let right = 2 * i + 2;
+        let swap = i;
+  
+        if (left < length && this.compare(this.data[left], this.data[swap])) {
+          swap = left;
+        }
+        if (right < length && this.compare(this.data[right], this.data[swap])) {
+          swap = right;
+        }
+        if (swap === i) break;
+  
+        this.data[i] = this.data[swap];
+        i = swap;
+      }
+  
+      this.data[i] = node;
+    }
+  }
+  
+  var MedianFinder = function () {
+    this.small = new Heap((a, b) => a > b); // max heap
+    this.large = new Heap((a, b) => a < b); // min heap
+  };
+  
+  MedianFinder.prototype.addNum = function (num) {
+    this.small.push(num);
+  
+    if (
+      this.small.size() > 0 &&
+      this.large.size() > 0 &&
+      this.small.peek() > this.large.peek()
+    ) {
+      this.large.push(this.small.pop());
+    }
+  
+    if (this.small.size() > this.large.size() + 1) {
+      this.large.push(this.small.pop());
+    }
+    if (this.large.size() > this.small.size() + 1) {
+      this.small.push(this.large.pop());
+    }
+  };
+  
+  MedianFinder.prototype.findMedian = function () {
+    if (this.small.size() > this.large.size()) {
+      return this.small.peek();
+    }
+    if (this.large.size() > this.small.size()) {
+      return this.large.peek();
+    }
+    return (this.small.peek() + this.large.peek()) / 2;
+  };
+
+  

insert-interval/hsskey.js

@@ -0,0 +1,27 @@
+/**
+ * @param {number[][]} intervals
+ * @param {number[]} newInterval
+ * @return {number[][]}
+ */
+var insert = function(intervals, newInterval) {
+    const res = [];
+  
+    for (let i = 0; i < intervals.length; i++) {
+      if (newInterval[1] < intervals[i][0]) {
+        res.push(newInterval);
+        return res.concat(intervals.slice(i));
+      } else if (newInterval[0] > intervals[i][1]) {
+        res.push(intervals[i]);
+      } else {
+        newInterval = [
+          Math.min(newInterval[0], intervals[i][0]),
+          Math.max(newInterval[1], intervals[i][1])
+        ];
+      }
+    }
+  
+    res.push(newInterval);
+    return res;
+  };
+  
+  

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

@@ -0,0 +1,38 @@
+/**
+ * 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) {
+    let n = 0;
+    const stack = [];
+    let cur = root;
+  
+    while (cur || stack.length > 0) {
+      while (cur) {
+        stack.push(cur);
+        cur = cur.left;
+      }
+  
+      cur = stack.pop();
+      n += 1;
+      if (n === k) {
+        return cur.val;
+      }
+  
+      cur = cur.right;
+    }
+  
+    return -1;
+  };
+  
+  

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

@@ -0,0 +1,31 @@
+/**
+ * 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 cur = root;
+  
+    while (cur) {
+      if (p.val > cur.val && q.val > cur.val) {
+        cur = cur.right;
+      } else if (p.val < cur.val && q.val < cur.val) {
+        cur = cur.left;
+      } else {
+        return cur;
+      }
+    }
+  
+    return null;
+  };
+
+  

meeting-rooms/hsskey.js

@@ -0,0 +1,39 @@
+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 {Interval[]} intervals - an array of meeting time intervals
+     * @return {boolean} - whether a person could attend all meetings
+     */
+    canAttendMeetings(intervals) {
+      // start 기준으로 정렬
+      intervals.sort((a, b) => a.start - b.start);
+  
+      // 연속된 회의의 시간 비교
+      for (let i = 1; i < intervals.length; i++) {
+        const prev = intervals[i - 1];
+        const curr = intervals[i];
+  
+        if (prev.end > curr.start) {
+          return false;
+        }
+      }
+  
+      return true;
+    }
+  }
+
+  
+