[wjsdncl] 24.12.03

wjsdncl/100_same_tree.js

@@ -0,0 +1,24 @@
+/**
+ * 24m40s 소요
+ *
+ * 시간복잡도: O(n) n = 트리의 노드 개수
+ *
+ * & 비트 연산자를 사용하여 두 트리의 노드를 비교합니다.
+ * 이진 트리를 처음 알게 되었는데 이진 트리의 구조를 이해하는 데 도움이 되었습니다.
+ * val은 현재 노드의 값이고 left와 right는 왼쪽과 오른쪽 자식 노드를 가리킵니다.
+ *
+ * 두 트리가 모두 null인 경우 두 트리는 동일합니다.
+ * 둘 중 하나가 null이거나 노드의 값이 다르면 트리는 동일하지 않습니다.
+ * 현재 노드가 같다면 왼쪽과 오른쪽 자식을 재귀적으로 비교합니다.
+ * 두 트리가 동일하다면 true를 반환하고 그렇지 않다면 false를 반환합니다.
+ */
+var isSameTree = function (p, q) {
+  // 둘 다 null인 경우 두 트리는 동일
+  if (!p && !q) return true;
+
+  // 둘 중 하나가 null이거나 노드의 값이 다르면 트리는 동일하지 않음
+  if (!p || !q || p.val !== q.val) return false;
+
+  // 현재 노드가 같다면 왼쪽과 오른쪽 자식을 재귀적으로 비교 (O(n))
+  return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
+};

wjsdncl/102_binary_tree_level_order_traversal.js

@@ -0,0 +1,35 @@
+/**
+ * 32m13s 소요
+ *
+ * 시간복잡도: O(n)
+ *
+ * 이진 트리의 노드 값을 레벨 순서대로 반환하는 문제입니다.
+ *
+ * 큐를 이용하여 레벨 순서대로 노드 값을 저장하고, 결과를 반환합니다.
+ * 빈 트리인 경우 빈 배열을 반환합니다.
+ */
+var levelOrder = function (root) {
+  if (!root) return []; // 빈 트리인 경우 빈 배열 반환
+
+  const result = [];
+  const queue = [root]; // 루트 노드를 큐에 넣는다.
+
+  while (queue.length) {
+    const level = [];
+    const len = queue.length;
+
+    // 큐에 있는 노드를 모두 빼내서 level 배열에 넣는다.
+    for (let i = 0; i < len; i++) {
+      const node = queue.shift();
+      level.push(node.val);
+
+      // 왼쪽 자식 노드와 오른쪽 자식 노드를 큐에 넣는다.
+      if (node.left) queue.push(node.left);
+      if (node.right) queue.push(node.right);
+    }
+
+    result.push(level);
+  }
+
+  return result;
+};

wjsdncl/1046_last_stone_weight.js

@@ -0,0 +1,26 @@
+/**
+ * 21m44s 소요
+ *
+ * 1. sort()로 내림차순 정렬한다.
+ * 2. 가장 큰 두개를 빼고 뺀 값이 0이 아니면 다시 배열에 넣는다.
+ * 3. 2를 반복한다. 배열의 길이가 1이하면 종료한다.
+ * 4. 배열의 길이가 0이면 0을 반환하고 아니면 배열의 첫번째 값을 반환한다.
+ */
+var lastStoneWeight = function (stones) {
+  // 내림차순 정렬 후 가장 큰 두개를 빼고 뺀 값이 0이 아니면 다시 배열에 넣는다. (O(n^2))
+  while (stones.length > 1) {
+    // 내림차순 정렬 (O(n log n))
+    stones.sort((a, b) => b - a);
+
+    // 가장 큰 두개를 빼고 뺀 값이 0이 아니면 다시 배열에 넣는다. (O(n))
+    const first = stones.shift();
+    const second = stones.shift();
+
+    // 뺀 값이 0이 아니면 다시 배열에 넣는다.
+    if (first !== second) {
+      stones.push(first - second);
+    }
+  }
+
+  return stones.length ? stones[0] : 0;
+};

wjsdncl/104_maximum_depth_of_binary_tree.js

@@ -0,0 +1,22 @@
+/**
+ * 38m21s
+ *
+ * 시간 복잡도: O(n)
+ *
+ * 이진 트리의 최대 깊이를 구하는 문제입니다.
+ * 재귀적으로 왼쪽 서브트리와 오른쪽 서브트리의 최대 깊이를 구하고 더 큰 값에 1을 더해 반환합니다.
+ * 루트가 null인 경우 깊이는 0입니다.
+ */
+var maxDepth = function (root) {
+  // 루트가 null인 경우, 깊이는 0
+  if (root === null) {
+    return 0;
+  }
+
+  // 왼쪽과 오른쪽 서브트리의 최대 깊이를 구함
+  const leftDepth = maxDepth(root.left);
+  const rightDepth = maxDepth(root.right);
+
+  // 더 큰 깊이에 1을 더해 반환
+  return Math.max(leftDepth, rightDepth) + 1;
+};

wjsdncl/110_balanced_binary_tree.js

@@ -0,0 +1,29 @@
+/**
+ * 35m 33s 소요
+ *
+ * 시간복잡도: O(n)
+ *
+ * 이진 트리 공부좀 더 해야할 거 같습니다 잘 모르겠어서 풀이를 참고했습니다.
+ *
+ * 1. 재귀를 이용하여 트리의 높이를 구합니다.
+ * 2. 재귀적으로 왼쪽과 오른쪽 자식 노드의 높이를 비교합니다.
+ * 3. 높이 차이가 1 이상이면 false를 반환합니다.
+ * 4. 높이 차이가 1 이하이면 현재 노드의 높이를 반환합니다.
+ */
+var isBalanced = function (root) {
+  const checkHeight = (node) => {
+    if (node === null) return 0;
+
+    const leftHeight = checkHeight(node.left);
+    if (leftHeight === -1) return -1;
+
+    const rightHeight = checkHeight(node.right);
+    if (rightHeight === -1) return -1;
+
+    if (Math.abs(leftHeight - rightHeight) > 1) return -1;
+
+    return Math.max(leftHeight, rightHeight) + 1;
+  };
+
+  return checkHeight(root) !== -1;
+};

wjsdncl/121_best_time_to_buy_and_sell_stock.js

@@ -0,0 +1,26 @@
+/*
+/ 16분 소요
+/
+/ 시간복잡도: O(n)
+/
+/ 최소값과 최대 이익을 저장해두고 배열을 순회하며 최소값과 최대 이익을 갱신합니다.
+/ 마지막 최대 이익을 반환합니다.
+*/
+var maxProfit = function (prices) {
+  let minPrice = prices[0];
+  let maxProfit = 0;
+
+  // 배열 순회 (O(n))
+  for (let i = 1; i < prices.length; i++) {
+    // 최소값 갱신
+    if (prices[i] < minPrice) {
+      minPrice = prices[i];
+    }
+    // 최대 이익 갱신
+    else if (prices[i] - minPrice > maxProfit) {
+      maxProfit = prices[i] - minPrice;
+    }
+  }
+
+  return maxProfit;
+};

wjsdncl/128_longest_consecutive_sequence.js

@@ -0,0 +1,59 @@
+/**
+ * 26m13s 소요
+ *
+ * 시간복잡도: O(n)
+ *
+ * 배열이 주어졌을 때 연속된 숫자로 이루어진 가장 긴 부분 배열의 길이를 구하는 문제입니다.
+ * 기존에 풀었던 방식은 O(n log n)이 소요되는데 O(n)으로 줄일 방법을 잘 모르겠어서 풀이를 참고했습니다.
+ */
+var longestConsecutive = function (nums) {
+  if (nums.length === 0) return 0;
+
+  // 중복된 숫자를 제거합니다.
+  let set = new Set(nums);
+  let max = 1;
+
+  for (let num of set) {
+    // num - 1이 set에 없다면 num을 시작으로 연속된 숫자들을 찾습니다.
+    if (!set.has(num - 1)) {
+      let currentMax = 1;
+
+      // num + 1이 set에 있다면 연속된 숫자를 찾습니다.
+      while (set.has(num + 1)) {
+        num++;
+        currentMax++;
+      }
+
+      // 최대길이를 구합니다.
+      max = Math.max(max, currentMax);
+    }
+  }
+
+  return max;
+};
+
+/*
+기존 풀이 방법
+
+var longestConsecutive = function (nums) {
+  if (nums.length === 0) return 0;
+
+  중복된 숫자를 제거하고 오름차순으로 정렬합니다.
+  const arr = Array.from(new Set(nums)).sort((a, b) => a - b);
+  let count = 1;
+  let long = 1;
+
+  for (let i = 0; i < arr.length; i++) {
+    현재 숫자가 이전 숫자보다 1 크다면 연속된 숫자입니다.
+    if (arr[i] === arr[i - 1] + 1) {
+      count++;
+    } else { 
+      연속된 숫자가 아니라면 최대값을 갱신합니다. 
+      long = Math.max(long, count);
+      count = 1;
+    }
+  }
+
+  return Math.max(long, count);
+};
+*/

wjsdncl/136_single_number.js

@@ -0,0 +1,19 @@
+/**
+ * 12m 21s 소요
+ *
+ * 시간복잡도: O(n)
+ *
+ * 1. XOR 연산을 이용한다.
+ * 2. XOR 연산은 두 값이 같으면 0, 다르면 1을 반환한다.
+ * 3. 배열의 모든 요소를 XOR 연산하면 한번만 나오는 요소만 남는다.
+ * 4. 남은 요소를 반환한다.
+ */
+var singleNumber = function (nums) {
+  let result = 0;
+
+  for (let num of nums) {
+    result ^= num;
+  }
+
+  return result;
+};

wjsdncl/139_word_break.js

@@ -0,0 +1,33 @@
+/**
+ * 13m38s 소요
+ *
+ * 시간복잡도: O(n^2)
+ *
+ * 단어 s가 주어지고, 단어 사전 wordDict가 주어집니다.
+ * 단어 s를 단어 사전을 이용하여 구성할 수 있는지 여부를 반환하는 문제입니다.
+ *
+ * dp를 사용하여 풀 수 있습니다.
+ * dp[i]는 s의 0부터 i까지의 부분 문자열이 단어 사전을 이용하여 구성 가능한지 여부를 나타냅니다.
+ * dp[0]은 빈 문자열이므로 true로 초기화합니다.
+ * dp[i]를 구하기 위해 dp[j]를 검사합니다. (0 <= j < i)
+ * dp[j]가 true이고, s의 j부터 i까지의 부분 문자열이 단어 사전에 있는 경우 dp[i]를 true로 설정합니다.
+ * dp[s.length]를 반환합니다.
+ */
+var wordBreak = function (s, wordDict) {
+  const wordSet = new Set(wordDict); // 빠른 검색을 위한 Set 생성
+  const dp = new Array(s.length + 1).fill(false);
+  dp[0] = true; // 빈 문자열은 항상 구성 가능
+
+  // dp[i]를 구하기 위해 dp[j]를 검사
+  for (let i = 1; i <= s.length; i++) {
+    // dp[j]가 true이고, s의 j부터 i까지의 부분 문자열이 단어 사전에 있는 경우 dp[i]를 true로 설정
+    for (let j = 0; j < i; j++) {
+      if (dp[j] && wordSet.has(s.slice(j, i))) {
+        dp[i] = true;
+        break; // 가능한 경우를 찾으면 더 이상 탐색하지 않음
+      }
+    }
+  }
+
+  return dp[s.length];
+};

wjsdncl/141_linked_list_cycle.js

@@ -0,0 +1,30 @@
+/**
+ * 32m15s
+ *
+ * 시간 복잡도: O(n)
+ *
+ * 찾아보니 토끼와 거북이 알고리즘으로 풀 수 있는 문제였습니다.
+ *
+ * 두 포인터를 이용하여 사이클이 존재하는지 확인합니다.
+ * slow는 한 칸씩 fast는 두 칸씩 이동합니다.
+ * 만약 slow와 fast가 만나면 사이클이 존재합니다.
+ * 만나지 않으면 사이클이 존재하지 않습니다.
+ */
+var hasCycle = function (head) {
+  let slow = head;
+  let fast = head;
+
+  // fast와 fast.next가 null이 아닌 동안 반복
+  while (fast !== null && fast.next !== null) {
+    slow = slow.next; // slow는 한 칸 이동
+    fast = fast.next.next; // fast는 두 칸 이동
+
+    // slow와 fast가 만나는 경우 사이클 존재
+    if (slow === fast) {
+      return true;
+    }
+  }
+
+  // 반복이 끝날 때까지 만나지 않으면 사이클이 없음
+  return false;
+};

wjsdncl/150_evaluate_reverse_polish_notation.js

@@ -0,0 +1,43 @@
+/**
+ * 19m26s 소요
+ *
+ * 시간복잡도 : O(n)
+ *
+ * 배열로 주어진 reverse polish notation을 계산하는 문제입니다.
+ * reverse polish notation를 보고 어려운 줄 알았는데 그냥 순서대로 계산만 하면 되는 문제였습니다.
+ *
+ * 숫자인 경우 스택에 push하고, 연산자인 경우 스택에서 두 숫자를 pop하여 연산한 결과를 다시 스택에 push합니다.
+ * 최종적으로 스택에 남아 있는 값을 반환합니다.
+ */
+var evalRPN = function (tokens) {
+  const stack = [];
+
+  for (let token of tokens) {
+    if (!isNaN(token)) {
+      // 숫자인 경우 스택에 push
+      stack.push(Number(token));
+    } else {
+      // 연산자인 경우 스택에서 두 숫자를 pop
+      const b = stack.pop();
+      const a = stack.pop();
+
+      switch (token) {
+        case "+":
+          stack.push(a + b);
+          break;
+        case "-":
+          stack.push(a - b);
+          break;
+        case "*":
+          stack.push(a * b);
+          break;
+        case "/":
+          stack.push(parseInt(a / b));
+          break;
+      }
+    }
+  }
+
+  // 스택에 남아 있는 최종 결과 반환
+  return stack.pop();
+};

wjsdncl/155_min_stack.js

@@ -0,0 +1,33 @@
+/**
+ * 31m 11s 소요
+ *
+ * 시간복잡도 : O(1)
+ *
+ * 지피티와 함께 풀었습니다 어렵네요
+ */
+var MinStack = function () {
+  this.stack = [];
+  this.minStack = [];
+};
+
+MinStack.prototype.push = function (val) {
+  this.stack.push(val);
+  if (this.minStack.length === 0 || val <= this.minStack[this.minStack.length - 1]) {
+    this.minStack.push(val);
+  }
+};
+
+MinStack.prototype.pop = function () {
+  const poppedValue = this.stack.pop();
+  if (poppedValue === this.minStack[this.minStack.length - 1]) {
+    this.minStack.pop();
+  }
+};
+
+MinStack.prototype.top = function () {
+  return this.stack[this.stack.length - 1];
+};
+
+MinStack.prototype.getMin = function () {
+  return this.minStack[this.minStack.length - 1];
+};