Merge pull request #1089 from jdy8739/main

[jdy8739] Week 14

Author: jdy8739

binary-tree-level-order-traversal/jdy8739.js

@@ -0,0 +1,42 @@
+/**
+ * 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 levelOrder = function (root) {
+    if (!root) {
+        return [];
+    }
+
+    const queue = [root];
+    const answer = [];
+
+    while (queue.length > 0) {
+        const values = [];
+
+        const currentQueueLen = queue.length;
+
+        for (let i = 0; i < currentQueueLen; i++) {
+            const head = queue.shift();
+
+            values.push(head.val);
+
+            head.left && queue.push(head.left);
+            head.right && queue.push(head.right);
+        }
+
+        answer.push(values);
+    }
+
+    return answer;
+};
+
+// 시간복잡도 O(n) -> 모든 노드를 한번씩 너비우선탐색으로 방문하므로
+// 공간복잡도 O(n) -> 큐에 모든 노드의 값을 저장하므로

counting-bits/jdy8739.js

@@ -0,0 +1,50 @@
+/**
+ * @param {number} n
+ * @return {number[]}
+ */
+var countBits = function (n) {
+    const arr = [0];
+
+    for (let i = 1; i <= n; i++) {
+        const num = binary(i);
+        arr.push(num);
+    }
+
+    return arr;
+};
+
+/** 성능이 느리지만 간결한 함수 */
+function binary(n) {
+    return n.toString(2).split('').filter((el) => el === '1').length;
+}
+
+// 시간복잡도 O(n2) -> n을 이진수문자열로 변환하고 이를 벼열화하여 1인 원소만 필터링하고 그 결과의 길이를 구한다.
+// 여기서 filter를 사용하여 배열을 한 번 순회하기 때문에 for문과 중첩되어 2중 루프의 시간복잡도를 가짐
+
+/** 성능이 빠르지만 복잡한 함수 */
+function binary(n) {
+    let num = 1;
+    let count = 0;
+
+    while (num * 2 <= n) {
+        num = num * 2;
+    }
+
+    while (0 <= n) {
+        if (num <= n) {
+            n = n - num;
+            count++;
+        }
+
+        if (num === 1) {
+            break;
+        }
+
+        num = num / 2;
+    }
+
+    return count;
+}
+
+// 시간복잡도 O(n2) -> for문 안에 while문이 돌면서 i가 이진수로 변환될 경우 1이 몇개인지 반환하기 때문에 2중 루프의 시간복잡도를 가짐
+// 공간복잡도 O(n) -> for문을 돌면서 arr에 i가 이진수로 변환될 경우 1이 몇 개인지 원소로 추가함

house-robber-ii/jdy8739.js

@@ -0,0 +1,27 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var rob = function (nums) {
+    if (nums.length === 1) {
+        return nums[0];
+    }
+
+    const dp1 = [0, nums[0]];
+    const dp2 = [0, 0];
+
+    for (let i = 1; i < nums.length; i++) {
+        const prevIndex = i - 1;
+
+        const dp1Max = Math.max(dp1[prevIndex] + nums[i], dp1[i]);
+        dp1.push(dp1Max);
+
+        const dp2Max = Math.max(dp2[prevIndex] + nums[i], dp2[i]);
+        dp2.push(dp2Max);
+    }
+
+    return Math.max(dp1[dp1.length - 2], dp2[dp2.length - 1])
+};
+
+// 시간복잡도 O(n) -> nums의 길이만큼 for문에서 최대값을 dp계산
+// 공간복잡도 O(n) -> nums의 길이만큼 dp배열에 원소가 추가됨