From a6e2de7a2f796b6d1488b1483f8c3a9bcc8627e2 Mon Sep 17 00:00:00 2001 From: Finn <82873315+uraflower@users.noreply.github.com> Date: Mon, 21 Apr 2025 15:53:00 +0900 Subject: [PATCH 1/5] [ PS ] : Merge Two Sorted Lists --- merge-two-sorted-lists/uraflower.js | 40 +++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) create mode 100644 merge-two-sorted-lists/uraflower.js diff --git a/merge-two-sorted-lists/uraflower.js b/merge-two-sorted-lists/uraflower.js new file mode 100644 index 000000000..2745365ca --- /dev/null +++ b/merge-two-sorted-lists/uraflower.js @@ -0,0 +1,40 @@ +/** + * Definition for singly-linked list. + */ +function ListNode(val, next) { + this.val = (val === undefined ? 0 : val) + this.next = (next === undefined ? null : next) +} + +/** + * 주어진 두 연결 리스트를 하나의 정렬 리스트로 병합해 반환하는 함수 + * @param {ListNode} list1 + * @param {ListNode} list2 + * @return {ListNode} + */ +const mergeTwoLists = function (list1, list2) { + let head = new ListNode(-1, null); + let mergedList = head; + + let node1 = list1; + let node2 = list2; + + while (node1 && node2) { + if (node1.val >= node2.val) { + mergedList.next = node2; + node2 = node2.next; + } else if (node1.val < node2.val) { + mergedList.next = node1; + node1 = node1.next; + } + + mergedList = mergedList.next; + } + + mergedList.next = node1 ?? node2; + + return head.next; +}; + +// 시간복잡도: O(n) +// 공간복잡도: O(n) From 8174793a279f54286af9de577cdf0c2bc3da4a45 Mon Sep 17 00:00:00 2001 From: Finn <82873315+uraflower@users.noreply.github.com> Date: Tue, 22 Apr 2025 12:33:34 +0900 Subject: [PATCH 2/5] [ PS ] : Maximum Depth of Binary Tree --- maximum-depth-of-binary-tree/uraflower.js | 31 +++++++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 maximum-depth-of-binary-tree/uraflower.js diff --git a/maximum-depth-of-binary-tree/uraflower.js b/maximum-depth-of-binary-tree/uraflower.js new file mode 100644 index 000000000..d187f1480 --- /dev/null +++ b/maximum-depth-of-binary-tree/uraflower.js @@ -0,0 +1,31 @@ +/** + * 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} + */ +const maxDepth = function(root) { + let maxDepth = 0; + + function bfs(node, depth) { + if (!node) return; + + depth += 1; + if (maxDepth < depth) maxDepth = depth; + bfs(node.left, depth); + bfs(node.right, depth); + } + + bfs(root, maxDepth); + return maxDepth; +}; + +// 시간복잡도: O(n) +// 공간복잡도: O(h) (h: 트리의 높이. 최악의 경우 편향트리일 때 h===n으로 O(n)) From 26cb9700f6a952f88811cd52cc2b4222e3b22845 Mon Sep 17 00:00:00 2001 From: Finn <82873315+uraflower@users.noreply.github.com> Date: Thu, 24 Apr 2025 17:50:45 +0900 Subject: [PATCH 3/5] [ PS ] : Find Minimum in Rotated Sorted Array --- .../uraflower.js | 35 +++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 find-minimum-in-rotated-sorted-array/uraflower.js diff --git a/find-minimum-in-rotated-sorted-array/uraflower.js b/find-minimum-in-rotated-sorted-array/uraflower.js new file mode 100644 index 000000000..7fca46f6d --- /dev/null +++ b/find-minimum-in-rotated-sorted-array/uraflower.js @@ -0,0 +1,35 @@ +/** + * 주어진 배열의 최솟값을 반환하는 함수 + * @param {number[]} nums + * @return {number} + */ +// 첫 번째 시도 +const findMin = function(nums) { + return Math.min(...nums); +}; + +// 시간복잡도: O(n) +// 공간복잡도: O(1) + +// =========================================== +// 두 번째 시도 +const findMin = function(nums) { + let left = 0; + let right = nums.length - 1; + let mid; + + while (left < right) { + mid = Math.floor((left + right) / 2); + + if (nums[mid] < nums[right]) { + right = mid; + } else { + left = mid + 1; + } + } + + return nums[left]; +} + +// 시간복잡도: O(logn) +// 공간복잡도: O(1) From 77ed47affd811202c8c9dbea3c354e68f5f8d340 Mon Sep 17 00:00:00 2001 From: Finn <82873315+uraflower@users.noreply.github.com> Date: Fri, 25 Apr 2025 01:03:28 +0900 Subject: [PATCH 4/5] Create uraflower.js --- word-search/uraflower.js | 46 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 word-search/uraflower.js diff --git a/word-search/uraflower.js b/word-search/uraflower.js new file mode 100644 index 000000000..97401e63f --- /dev/null +++ b/word-search/uraflower.js @@ -0,0 +1,46 @@ +/** + * 주어진 2차 배열에 word가 있는지 여부를 반환하는 함수 + * @param {character[][]} board + * @param {string} word + * @return {boolean} + */ +const exist = function (board, word) { + const row = board.length; + const col = board[0].length; + const visited = Array.from({ length: row }, () => Array(col).fill(false)); + const dr = [0, 0, 1, -1]; + const dc = [1, -1, 0, 0]; + + function dfs(r, c, charIdx) { + + if (charIdx + 1 === word.length) return true; + + for (let i = 0; i < 4; i++) { + const nr = r + dr[i]; + const nc = c + dc[i]; + + if (0 <= nr && nr < row && 0 <= nc && nc < col && !visited[nr][nc] && word[charIdx + 1] === board[nr][nc]) { + visited[nr][nc] = true; + if (dfs(nr, nc, charIdx + 1)) return true; + visited[nr][nc] = false; + } + } + + return false; + } + + for (let r = 0; r < row; r++) { + for (let c = 0; c < col; c++) { + if (word[0] === board[r][c]) { + visited[r][c] = true; + if (dfs(r, c, 0)) return true; + visited[r][c] = false; + } + } + } + + return false; +}; + +// 시간복잡도: O(m * n * 4^L) (L = word.length. 네 방향으로 최대 L만큼 수행할 수 있음.) +// 공간복잡도: O(m * n) From 12117a44ddb0b07c6dceef1f82bcb5d6a367e7c3 Mon Sep 17 00:00:00 2001 From: Finn <82873315+uraflower@users.noreply.github.com> Date: Sat, 26 Apr 2025 15:42:39 +0900 Subject: [PATCH 5/5] [ PS ] : Coin Change --- coin-change/uraflower.js | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 coin-change/uraflower.js diff --git a/coin-change/uraflower.js b/coin-change/uraflower.js new file mode 100644 index 000000000..752888441 --- /dev/null +++ b/coin-change/uraflower.js @@ -0,0 +1,20 @@ +/** + * 주어진 금액을 동전으로 거스를 때 최소 동전 개수를 반환하는 함수 + * @param {number[]} coins + * @param {number} amount + * @return {number} + */ +const coinChange = function (coins, amount) { + const dp = [0, ...Array(amount).fill(amount + 1)]; + + for (let coin of coins) { + for (let n = coin; n <= amount; n++) { + dp[n] = Math.min(dp[n], dp[n - coin] + 1) + } + } + + return dp[amount] > amount ? -1 : dp[amount] +}; + +// 시간복잡도: O(c*n) (c: coins.length, n: amount) +// 공간복잡도: O(n)