From 247014dee2ac6f71817dd6a46adeddf6f02f7096 Mon Sep 17 00:00:00 2001 From: HoonDongKang Date: Mon, 2 Jun 2025 23:43:08 +0900 Subject: [PATCH 1/5] add Invert Binary Tree solution --- invert-binary-tree/HoonDongKang.ts | 53 ++++++++++++++++++++++++++++++ 1 file changed, 53 insertions(+) create mode 100644 invert-binary-tree/HoonDongKang.ts diff --git a/invert-binary-tree/HoonDongKang.ts b/invert-binary-tree/HoonDongKang.ts new file mode 100644 index 000000000..3314e0d94 --- /dev/null +++ b/invert-binary-tree/HoonDongKang.ts @@ -0,0 +1,53 @@ +/** + * [Problem]: [226] Invert Binary Tree + * (https://leetcode.com/problems/invert-binary-tree/) + */ + +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 { + // 시간복잡도 O(n) + // 공간복잡도 O(n) + function recursiveFunc(root: TreeNode | null): TreeNode | null { + if (root === null) { + return null; + } + + const temp = root.left; + root.left = invertTree(root.right); + root.right = invertTree(temp); + + return root; + } + // 시간복잡도 O(n) + // 공간복잡도 O(n) + function stackFunc(root: TreeNode | null): TreeNode | null { + if (root === null) { + return null; + } + + const stack: Array = [root]; + + while (stack.length > 0) { + const node = stack.pop()!; + + if (node === null) { + continue; + } + + [node.left, node.right] = [node.right, node.left]; + stack.push(node.left, node.right); + } + + return root; + } +} From f6e471c96988e81a5eb590ac03e97e48e7c59698 Mon Sep 17 00:00:00 2001 From: HoonDongKang Date: Tue, 3 Jun 2025 12:24:02 +0900 Subject: [PATCH 2/5] add Search in Rotated Sorted Array solution --- .../HoonDongKang.ts | 32 +++++++++++++++++++ 1 file changed, 32 insertions(+) create mode 100644 search-in-rotated-sorted-array/HoonDongKang.ts diff --git a/search-in-rotated-sorted-array/HoonDongKang.ts b/search-in-rotated-sorted-array/HoonDongKang.ts new file mode 100644 index 000000000..71b6e932c --- /dev/null +++ b/search-in-rotated-sorted-array/HoonDongKang.ts @@ -0,0 +1,32 @@ +/** + * [Problem]: [33] Search in Rotated Sorted Array + * (https://leetcode.com/problems/search-in-rotated-sorted-array/description/) + */ +function search(nums: number[], target: number): number { + //시간복잡도 O(log n) + //공간복잡도 O(1) + let left = 0; + let right = nums.length - 1; + + while (left <= right) { + let mid = Math.floor((left + right) / 2); + + if (nums[mid] === target) return mid; + + if (nums[left] <= nums[mid]) { + 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; +} From 9b4dd42669176fe12fecc904c1ed76f4eafb5fd9 Mon Sep 17 00:00:00 2001 From: HoonDongKang Date: Wed, 4 Jun 2025 11:32:03 +0900 Subject: [PATCH 3/5] add Course Schedule solution --- course-schedule/HoonDongKang.ts | 42 +++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) create mode 100644 course-schedule/HoonDongKang.ts diff --git a/course-schedule/HoonDongKang.ts b/course-schedule/HoonDongKang.ts new file mode 100644 index 000000000..6446e5989 --- /dev/null +++ b/course-schedule/HoonDongKang.ts @@ -0,0 +1,42 @@ +/** + * [Problem]: [207] Course Schedule + * (https://leetcode.com/problems/course-schedule/description/) + */ + +function canFinish(numCourses: number, prerequisites: number[][]): boolean { + // 시간복잡도 O(n+m) + // 공간복잡도 O(n+m) + function graphFunc(numCourses: number, prerequisites: number[][]): boolean { + const graph: number[][] = Array.from({ length: numCourses }, () => []); + + for (const [course, prerequisite] of prerequisites) { + graph[prerequisite].push(course); + } + + let traversing = new Array(numCourses).fill(false); + let visited = new Array(numCourses).fill(false); + + function dfs(course: number): boolean { + if (traversing[course]) return false; + if (visited[course]) return true; + + traversing[course] = true; + for (let pre of graph[course]) { + if (!dfs(pre)) { + return false; + } + } + + traversing[course] = false; + visited[course] = true; + return true; + } + + for (let i = 0; i < numCourses; i++) { + if (!visited[i] && !dfs(i)) { + return false; + } + } + return true; + } +} From 4db816516e3271f869d82880a6b030d7471db744 Mon Sep 17 00:00:00 2001 From: HoonDongKang Date: Thu, 5 Jun 2025 11:20:43 +0900 Subject: [PATCH 4/5] add Jump Game solution --- jump-game/HoonDongKang.ts | 71 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 71 insertions(+) create mode 100644 jump-game/HoonDongKang.ts diff --git a/jump-game/HoonDongKang.ts b/jump-game/HoonDongKang.ts new file mode 100644 index 000000000..7e421900d --- /dev/null +++ b/jump-game/HoonDongKang.ts @@ -0,0 +1,71 @@ +/** + * [Problem]: [55] Jump Game + * (https://leetcode.com/problems/jump-game/description/) + */ +function canJump(nums: number[]): boolean { + // 시간복잡도 O(N^N) + // 공간복잡도 O(N) + // Time Limit Exceeded + function dfsFunc(nums: number[]): boolean { + function dfs(start: number): boolean { + if (start === nums.length - 1) return true; + for (let i = 1; i <= nums[start]; i++) { + if (dfs(start + i)) return true; + } + return false; + } + return dfs(0); + } + // 시간복잡도 O(N^2) + // 공간복잡도 O(N) + function dpFunc(nums: number[]): boolean { + const n = nums.length; + const dp = Array(n).fill(false); + dp[0] = true; + + for (let i = 1; i < n; i++) { + for (let j = 0; j < i; j++) { + if (dp[j] && j + nums[j] >= i) { + dp[i] = true; + break; + } + } + } + + return dp[n - 1]; + } + // 시간복잡도 O(N^2) + // 공간복잡도 O(N) + function memoFunc(nums: number[]): boolean { + let memo = new Map(); + + function dfs(start: number): boolean { + if (start === nums.length - 1) return true; + if (memo.has(start)) return memo.get(start)!; + for (let i = 1; i <= nums[start]; i++) { + if (dfs(start + i)) { + memo.set(start, true); + return true; + } + } + + memo.set(start, false); + return false; + } + + return dfs(0); + } + + // 시간복잡도 O(N) + // 공간복잡도 O(1) + function greedyFunc(nums: number[]): boolean { + let reach = 0; + for (let i = 0; i < nums.length; i++) { + if (i <= reach) { + reach = Math.max(reach, i + nums[i]); + } + } + + return nums.length - 1 <= reach; + } +} From 97e10baeb3606f49abc0e9469bddd8b234822177 Mon Sep 17 00:00:00 2001 From: HoonDongKang Date: Fri, 6 Jun 2025 12:00:46 +0900 Subject: [PATCH 5/5] add Merge k Sorted Lists solution --- merge-k-sorted-lists/HoonDongKang.ts | 101 +++++++++++++++++++++++++++ 1 file changed, 101 insertions(+) create mode 100644 merge-k-sorted-lists/HoonDongKang.ts diff --git a/merge-k-sorted-lists/HoonDongKang.ts b/merge-k-sorted-lists/HoonDongKang.ts new file mode 100644 index 000000000..c7794d016 --- /dev/null +++ b/merge-k-sorted-lists/HoonDongKang.ts @@ -0,0 +1,101 @@ +/** + * [Problem]: [23] Merge k Sorted Lists + * (https://leetcode.com/problems/merge-k-sorted-lists/description/) + */ + +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 { + //시간복잡도: O(n log n) + //공간복잡도: O(n) + function bruteForceFunc(lists: Array): ListNode | null { + const arr: number[] = []; + let dummy = new ListNode(0); + let current = dummy; + + if (!lists.length) return null; + + for (let i = 0; i < lists.length; i++) { + let currentNode = lists[i]; + while (currentNode) { + arr.push(currentNode.val); + currentNode = currentNode.next; + } + } + + arr.sort((a, b) => a - b); + + for (let j = 0; j < arr.length; j++) { + current.next = new ListNode(arr[j]); + current = current.next; + } + + return dummy.next; + } + + //시간복잡도: O(nk) + //공간복잡도: O(n) + function mergeFunc(lists: Array): ListNode | null { + let dummy = new ListNode(0); + let cur = dummy; + + while (lists.some((node) => node !== null)) { + let minVal = Infinity; + let minIdx = -1; + + for (let i = 0; i < lists.length; i++) { + if (lists[i] && lists[i]!.val < minVal) { + minVal = lists[i]!.val; + minIdx = i; + } + } + + if (minIdx !== -1) { + cur.next = new ListNode(minVal); + cur = cur.next; + lists[minIdx] = lists[minIdx]!.next; + } + } + + return dummy.next; + } + //시간복잡도: O(n log k) + //공간복잡도: O(log k) + function divideAndConqureFunc(lists: Array): ListNode | null { + if (!lists.length) return null; + if (lists.length === 1) return lists[0]; + + const mid = Math.floor(lists.length / 2); + const left = divideAndConqureFunc(lists.slice(0, mid)); + const right = divideAndConqureFunc(lists.slice(mid)); + + function mergeTwoLists(list1: ListNode | null, list2: ListNode | null): ListNode | null { + const dummy = new ListNode(-1); + let cur = dummy; + + while (list1 && list2) { + if (list1.val < list2.val) { + cur.next = list1; + list1 = list1.next; + } else { + cur.next = list2; + list2 = list2.next; + } + + cur = cur.next; + } + + cur.next = list1 ?? list2; + return dummy.next; + } + + return mergeTwoLists(left, right); + } +}