Merge pull request DaleStudy#748 from anniemon/main

[anniemon78] Week 2

Author: anniemon

3sum/anniemon.js

@@ -0,0 +1,41 @@
+/**
+ * 시간 복잡도:
+ *   nums의 길이만큼 for문을 순회하고, 내부에서 투 포인터로 또 한 번 순회하므로, O(n²)
+ * 공간 복잡도:
+ *   정렬은 추가 공간 사용이 없음.
+ *   res 배열의 크기는 고유한 세 숫자 조합의 갯수.
+ *   이를 k라고 하면, 공간 복잡도는 O(k)
+ */
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var threeSum = function (nums) {
+  nums.sort((a, b) => a - b);
+
+  const res = [];
+  for (let i = 0; i < nums.length; i++) {
+      if (i > 0 && nums[i] === nums[i - 1]) {
+          continue;
+      }
+
+      let l = i + 1;
+      let r = nums.length - 1;
+      while (l < r) {
+          const sum = nums[i] + nums[l] + nums[r];
+          if (sum > 0) {
+              r--;
+          } else if (sum < 0) {
+              l++;
+          } else if (sum === 0) {
+              res.push([nums[i], nums[l], nums[r]]);
+              l++;
+              r--;
+              while (l < r && nums[l] === nums[l - 1]) {
+                  l++;
+              }
+          }
+      }
+  }
+  return res;
+};

climbing-stairs/anniemon.js

@@ -0,0 +1,25 @@
+/**
+ * 시간 복잡도:
+ *   메모이제이션을 사용하여 n까지 가기 위한 방법의 수를 저장.
+ *   재귀 함수는 최대 n만큼 호출됨.
+ *   따라서, 시간 복잡도는 O(n)
+ * 공간 복잡도:
+ *   메모 객체의 크기는 n의 크기와 같음.
+ *   재귀 함수는 최대 n만큼 호출됨.
+ *   따라서, 공간 복잡도는 O(n)
+ */
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var climbStairs = function(n) {
+  const memo = [0, 1, 2];
+  const recurse = (n) => {
+      if(memo[n]) {
+          return memo[n];
+      }
+      memo[n] = recurse(n - 1) + recurse(n - 2);
+      return memo[n];
+  }
+  return recurse(n);
+};

construct-binary-tree-from-preorder-and-inorder-traversal/anniemon.js

@@ -0,0 +1,40 @@
+/**
+ * 시간 복잡도:
+ *   preIdx를 이용하여 중위 순회 배열에서 루트 노드를 기준으로 왼쪽 서브 트리와 오른쪽 서브 트리를 탐색.
+ *   각 서브 트리를 재귀적으로 생성하며 모든 노드를 한 번씩 순회하므로, 시간 복잡도는 O(n)
+ * 공간 복잡도:
+ *   중위 순회 배열의 길이만큼 맵을 생성하므로, 공간 복잡도는 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 {number[]} preorder
+ * @param {number[]} inorder
+ * @return {TreeNode}
+ */
+var buildTree = function(preorder, inorder) {
+  let preIdx = 0;
+  const inorderMap = new Map(inorder.map((e, i) => [e, i]))
+
+  const dfs = (l, r) => {
+      if(l > r) {
+          return null;
+      }
+      let root = preorder[preIdx];
+      preIdx++;
+
+      let rootIdx = inorderMap.get(root);
+
+      const node = new TreeNode(root);
+      node.left = dfs(l, rootIdx - 1);
+      node.right = dfs(rootIdx + 1, r);
+      return node;
+  }
+  return dfs(0, inorder.length - 1)
+};

valid-anagram/anniemon.js

@@ -0,0 +1,29 @@
+/**
+ * 시간 복잡도:
+ *   s와 t의 길이만큼 각 문자의 카운트를 기록하고 이를 확인하므로, 시간 복잡도는 O(n)
+ * 공간 복잡도:
+ *   카운트 객체는 최대 s와 t의 길이만큼 공간을 차지하므로, 공간 복잡도는 O(n)
+ */
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {boolean}
+ */
+var isAnagram = function (s, t) {
+  if (s.length !== t.length) {
+      return false;
+  }
+
+  const count = {};
+  for (let i = 0; i < s.length; i++) {
+      count[s[i]] = (count[s[i]] || 0) + 1;
+      count[t[i]] = (count[t[i]] || 0) - 1;
+  }
+
+  for (const key in count) {
+      if (count[key] !== 0) {
+          return false;
+      }
+  }
+  return true;
+};