[moonhyeok] Week10

invert-binary-tree/mike2ox.ts

@@ -0,0 +1,36 @@
+/**
+ * Source: https://leetcode.com/problems/invert-binary-tree/
+ * 풀이방법: 재귀를 이용하여 트리를 뒤집음
+ *
+ * 시간복잡도: O(n) - n은 트리의 노드 수
+ * 공간복잡도: O(n) - 재귀 호출에 따른 스택 메모리
+ *
+ * 다른 풀이방법
+ * - BFS를 이용하여 풀이
+ * - 스택을 이용하여 풀이
+ */
+
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
+
+function invertTree(root: TreeNode | null): TreeNode | null {
+  if (!root) return null;
+
+  const result = new TreeNode(
+    root.val,
+    invertTree(root.right),
+    invertTree(root.left)
+  );
+  return result;
+}

jump-game/mike2ox.ts

@@ -0,0 +1,21 @@
+/**
+ * Source: https://leetcode.com/problems/jump-game/
+ * 풀이방법: 그리디로 접근
+ *
+ * 시간복잡도: O(n) - nums의 요소들을 다 방문할 수 있음
+ * 공간복잡도: O(1) - 특정 위치만 기억해둘 필요가 있음
+ *
+ * 다른 풀이
+ * - DFS로 처음에 접근했으나 시간 오버로 인해 Fail
+ */
+
+function canJump(nums: number[]): boolean {
+  let goal = nums.length - 1;
+  for (let i = nums.length - 1; i >= 0; i--) {
+    const pos = nums[i];
+    if (pos + i >= goal) {
+      goal = i;
+    }
+  }
+  return goal === 0;
+}

merge-k-sorted-lists/mike2ox.ts

@@ -0,0 +1,48 @@
+/**
+ * Source: https://leetcode.com/problems/merge-k-sorted-lists/
+ * 풀이방법: 모든 리스트들을 한곳에 넣고 재배치
+ *
+ * 시간복잡도: O(NlogN) - 모든 리스트를 순회(N), 정렬(NlogN) 하는데 드는 시간 고려
+ * 공간복잡도: O(N) - 기존 배열을 저장할 공간만 필요
+ */
+
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     val: number
+ *     next: ListNode | null
+ *     constructor(val?: number, next?: ListNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.next = (next===undefined ? null : next)
+ *     }
+ * }
+ */
+
+function mergeKLists(lists: Array<ListNode | null>): ListNode | null {
+  if (!lists?.length) return null;
+  let merged = [];
+
+  for (let i = 0; i < lists.length; i++) {
+    let cursor = lists[i];
+    while (cursor != null) {
+      merged.push(cursor.val);
+      cursor = cursor.next;
+    }
+  }
+  let sorted = merged.sort((a, b) => (a < b ? -1 : 1));
+  let head = null;
+  let tail = null;
+
+  for (let i = 0; i < sorted.length; i++) {
+    const node = new ListNode(sorted[i], null);
+    if (head === null) {
+      head = node;
+      tail = node;
+    } else {
+      tail.next = node;
+      tail = node;
+    }
+  }
+
+  return head;
+}

search-in-rotated-sorted-array/mike2ox.ts

@@ -0,0 +1,28 @@
+/**
+ * Source: https://leetcode.com/problems/search-in-rotated-sorted-array/description/
+ * 풀이방법: 이진탐색을 구현해서 원하는 값을 찾음
+ *
+ * 시간복잡도: O(log n) - 매 반복마다 탐색 범위가 절반으로 줄어듦
+ * 공간복잡도: O(1) - 추가 공간을 사용하지 않고 포인터 변수만 사용
+ *
+ * 포인트
+ *  - 문제에서 시간 복잡도를 O(log n)을 하라고 제한을 했기때문에 쉽게 이진탐색으로 풀어야 함을 파악함
+ */
+
+function search(nums: number[], target: number): number {
+  let left = 0;
+  let right = nums.length - 1;
+
+  while (left <= right) {
+    let mid = Math.floor((left + right) / 2);
+    if (nums[mid] === target) return mid;
+    else if (nums[mid] >= nums[left]) {
+      if (nums[left] <= target && target <= nums[mid]) right = mid - 1;
+      else left = mid + 1;
+    } else {
+      if (nums[mid] <= target && target <= nums[right]) left = mid + 1;
+      else right = mid - 1;
+    }
+  }
+  return -1;
+}