From 69f4a44cf97413ddd2e16518ca9086f5033a5d17 Mon Sep 17 00:00:00 2001 From: minji-go Date: Mon, 16 Jun 2025 14:57:47 +0900 Subject: [PATCH 01/13] feat: same-tree --- same-tree/minji-go.java | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 same-tree/minji-go.java diff --git a/same-tree/minji-go.java b/same-tree/minji-go.java new file mode 100644 index 000000000..9a09ef02d --- /dev/null +++ b/same-tree/minji-go.java @@ -0,0 +1,36 @@ +import leetcode_study.TreeNode; + +import java.util.AbstractMap; +import java.util.Map; + +/** + * week12-1. same-tree + *
  • Description: Given the roots of two binary trees p and q, check if they are the same or not
    • + *
  • Topics: Tree, Depth-First Search, Breadth-First Search, Binary Tree
    • + *
  • Time Complexity: O(N), Runtime 0ms
    • + *
  • Space Complexity: O(N), Memory 41.14MB
    • + */ +class Solution { + public boolean isSameTree(TreeNode p, TreeNode q) { + Queue> queue = new LinkedList<>(); + queue.add(new AbstractMap.SimpleEntry<>(p, q)); + + while (!queue.isEmpty()) { + Map.Entry nodeMap = queue.poll(); + TreeNode nodeP = nodeMap.getKey(); + TreeNode nodeQ = nodeMap.getValue(); + + if (nodeP == null && nodeQ == null) { + continue; + } + if (nodeP == null || nodeQ == null || nodeP.val != nodeQ.val) { + return false; + } + + queue.add(new AbstractMap.SimpleEntry<>(nodeP.left, nodeQ.left)); + queue.add(new AbstractMap.SimpleEntry<>(nodeP.right, nodeQ.right)); + } + + return true; + } +} From a74d56cc95073e2b4399e01f32f6a5e1b494fb70 Mon Sep 17 00:00:00 2001 From: minji-go Date: Mon, 16 Jun 2025 14:57:53 +0900 Subject: [PATCH 02/13] feat: remove-nth-node-from-end-of-list --- .../minji-go.java | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 remove-nth-node-from-end-of-list/minji-go.java diff --git a/remove-nth-node-from-end-of-list/minji-go.java b/remove-nth-node-from-end-of-list/minji-go.java new file mode 100644 index 000000000..37a6e9efb --- /dev/null +++ b/remove-nth-node-from-end-of-list/minji-go.java @@ -0,0 +1,27 @@ +/** + * week12-2. remove-nth-node-from-end-of-list + *
  • Description: Given the head of a linked list, remove the nth node from the end of the list and return its head
    • + *
  • Topics: Linked List, Two Pointers
    • + *
  • Time Complexity: O(N), Runtime 0ms
    • + *
  • Space Complexity: O(1), Memory 41.95MB
    • + */ +class Solution { + public ListNode removeNthFromEnd(ListNode head, int n) { + ListNode dummy = new ListNode(0, head); + ListNode fast = dummy; + ListNode slow = dummy; + + for(int i=0; i<=n; i++){ + fast = fast.next; + } + + while (fast != null) { + slow = slow.next; + fast = fast.next; + } + + slow.next = slow.next.next; + + return dummy.next; + } +} From faf597f2ac43c7b05a348c43c10803239249bee9 Mon Sep 17 00:00:00 2001 From: minji-go Date: Tue, 17 Jun 2025 16:10:08 +0900 Subject: [PATCH 03/13] feat: non-overlapping-intervals --- non-overlapping-intervals/minji-go.java | 26 +++++++++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 non-overlapping-intervals/minji-go.java diff --git a/non-overlapping-intervals/minji-go.java b/non-overlapping-intervals/minji-go.java new file mode 100644 index 000000000..5432df3a0 --- /dev/null +++ b/non-overlapping-intervals/minji-go.java @@ -0,0 +1,26 @@ +/** + * week12-3. non-overlapping-intervals + *
  • Description: return the minimum number of intervals you need to remove to make the rest of the intervals non-overlapping
    • + *
  • Topics: Array, Dynamic Programming, Greedy, Sorting
    • + *
  • Time Complexity: O(N), Runtime 45ms
    • + *
  • Space Complexity: O(1), Memory 73.45MB
    • + *
  • Note : refer to the answer
    • + */ +class Solution { + public int eraseOverlapIntervals(int[][] intervals) { + Arrays.sort(intervals, (i1, i2) -> i1[1] - i2[1]); + + int skip = 0; + int end = Integer.MIN_VALUE; + + for (int[] interval : intervals) { + if (interval[0] < end) { + skip++; + } else { + end = interval[1]; + } + } + + return skip; + } +} From 1061026aa96130e5c2b14a38ab72aafa852abf9f Mon Sep 17 00:00:00 2001 From: minji-go Date: Tue, 17 Jun 2025 16:28:30 +0900 Subject: [PATCH 04/13] feat: jump-game --- jump-game/minji-go.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 jump-game/minji-go.java diff --git a/jump-game/minji-go.java b/jump-game/minji-go.java new file mode 100644 index 000000000..2a00b0540 --- /dev/null +++ b/jump-game/minji-go.java @@ -0,0 +1,19 @@ +/** + * week10-4. jump-game + *
  • Description: Return true if you can reach the last index, or false otherwise
    • + *
  • Topics: Array, Dynamic Programming, Greedy
    • + *
  • Time Complexity: O(N), Runtime 2ms
    • + *
  • Space Complexity: O(1), Memory 45.66MB
    • + */ +class Solution { + public boolean canJump(int[] nums) { + int jump = 0; + for (int i = 0; i <= jump; i++) { + jump = Math.max(jump, i + nums[i]); + if (jump >= nums.length - 1) { + return true; + } + } + return false; + } +} From 6fa701f1f8184f02c606d6ec239958cc84a4cb0b Mon Sep 17 00:00:00 2001 From: minji-go Date: Tue, 17 Jun 2025 17:44:22 +0900 Subject: [PATCH 05/13] feat: course-schedule --- course-schedule/minji-go.java | 45 +++++++++++++++++++++++++++++++++++ 1 file changed, 45 insertions(+) create mode 100644 course-schedule/minji-go.java diff --git a/course-schedule/minji-go.java b/course-schedule/minji-go.java new file mode 100644 index 000000000..2554d7c58 --- /dev/null +++ b/course-schedule/minji-go.java @@ -0,0 +1,45 @@ +/** + * week10-3. course-schedule + *
  • Description: Return true if you can finish all courses. Otherwise, return false
    • + *
  • Topics: Depth-First Search, Breadth-First Search, Graph, Topological Sort
    • + *
  • Time Complexity: O(N+E), Runtime 7ms
    • + *
  • Space Complexity: O(N+E), Memory 45.68MB
    • + *
  • Note : refer to the answer. remember the topic of topological sort
    • + */ +class Solution { + public boolean canFinish(int numCourses, int[][] prerequisites) { + int[] inDegree = new int[numCourses]; + List> graph = new ArrayList<>(); + for (int i=0; i()); + } + + for(int[] pre : prerequisites) { + int dest = pre[0], src = pre[1]; + graph.get(src).add(dest); + inDegree[dest]++; + } + + Queue queue = new LinkedList<>(); + for (int i=0; i Date: Wed, 18 Jun 2025 19:12:07 +0900 Subject: [PATCH 06/13] feat: serialize-and-deserialize-binary-tree --- .../minji-go.java | 65 +++++++++++++++++++ 1 file changed, 65 insertions(+) create mode 100644 serialize-and-deserialize-binary-tree/minji-go.java diff --git a/serialize-and-deserialize-binary-tree/minji-go.java b/serialize-and-deserialize-binary-tree/minji-go.java new file mode 100644 index 000000000..b7a6c1980 --- /dev/null +++ b/serialize-and-deserialize-binary-tree/minji-go.java @@ -0,0 +1,65 @@ +/** + * week12-4. serialize-and-deserialize-binary-tree + *
  • Description: Design an algorithm to serialize and deserialize a binary tree
    • + *
  • Topics: String, Tree, Depth-First Search, Breadth-First Search, Design, Binary Tree
    • + *
  • Time Complexity: O(N), Runtime 14ms
    • + *
  • Space Complexity: O(N), Memory 45.44MB
    • + */ +public class Codec { + + public String serialize(TreeNode root) { + if (root == null) { + return null; + } + + Queue queue = new LinkedList<>(); + queue.add(root); + + StringBuilder sb = new StringBuilder(); + while (!queue.isEmpty()) { + TreeNode node = queue.poll(); + if (node == null) { + sb.append("null,"); + continue; + } + sb.append(node.val).append(","); + queue.add(node.left); + queue.add(node.right); + } + + return sb.toString(); + } + + public TreeNode deserialize(String data) { + if (data == null) { + return null; + } + + String[] values = data.split(","); + + TreeNode root = new TreeNode(Integer.parseInt(values[0])); + Queue queue = new LinkedList<>(); + queue.add(root); + + int i = 1; + while (!queue.isEmpty()) { + TreeNode parent = queue.poll(); + + if (!values[i].equals("null")) { + TreeNode left = new TreeNode(Integer.parseInt(values[i])); + parent.left = left; + queue.add(left); + } + i++; + + if (!values[i].equals("null")) { + TreeNode right = new TreeNode(Integer.parseInt(values[i])); + parent.right = right; + queue.add(right); + } + i++; + } + + return root; + } +} From 360fe20a644a6f6fb4888b54e95b01441d473447 Mon Sep 17 00:00:00 2001 From: minji-go Date: Wed, 18 Jun 2025 19:20:45 +0900 Subject: [PATCH 07/13] feat: invert-binary-tree --- invert-binary-tree/minji-go.java | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 invert-binary-tree/minji-go.java diff --git a/invert-binary-tree/minji-go.java b/invert-binary-tree/minji-go.java new file mode 100644 index 000000000..1bf759396 --- /dev/null +++ b/invert-binary-tree/minji-go.java @@ -0,0 +1,26 @@ +/** + * week10-1. invert-binary-tree + *
  • Description: Design an algorithm to serialize and deserialize a binary tree
    • + *
  • Topics: Tree, Depth-First Search, Breadth-First Search, Binary Tree
    • + *
  • Time Complexity: O(N), Runtime 0ms
    • + *
  • Space Complexity: O(N), Memory 41.28MB
    • + */ +class Solution { + public TreeNode invertTree(TreeNode root) { + if (root == null) return null; + + Queue queue = new LinkedList<>(); + queue.offer(root); + + while (!queue.isEmpty()) { + TreeNode parent = queue.poll(); + TreeNode temp = parent.left; + parent.left = parent.right; + parent.right = temp; + if (parent.left != null) queue.offer(parent.left); + if (parent.right != null) queue.offer(parent.right); + } + + return root; + } +} From 8641c268690e56bade434de51819459802ff0f36 Mon Sep 17 00:00:00 2001 From: minji-go Date: Thu, 19 Jun 2025 15:46:35 +0900 Subject: [PATCH 08/13] feat: search-in-rotated-sorted-array --- search-in-rotated-sorted-array/minji-go.java | 60 ++++++++++++++++++++ 1 file changed, 60 insertions(+) create mode 100644 search-in-rotated-sorted-array/minji-go.java diff --git a/search-in-rotated-sorted-array/minji-go.java b/search-in-rotated-sorted-array/minji-go.java new file mode 100644 index 000000000..702dbc85c --- /dev/null +++ b/search-in-rotated-sorted-array/minji-go.java @@ -0,0 +1,60 @@ +/** + * week10-2. search-in-rotated-sorted-array + *
  • Description: nums is sorted in ascending order and is possibly rotated at an unknown pivot index. return the index of target if it is in nums, or -1
    • + *
  • Topics: Array, Binary Search
    • + *
  • Time Complexity: O(logN), Runtime 1ms
    • + *
  • Space Complexity: O(logN), Memory 43.23MB
    • + */ +class Solution { + public int search(int[] nums, int target) { + if(nums.length==1) { + if(nums[0]==target) return 0; + return -1; + } + + Queue queue = new LinkedList<>(); + queue.add(new int[]{0, nums.length-1}); + + int pivot = -1; + if(nums[0] nums.length-1) { + continue; + } + if(nums[mid]>nums[mid+1]) { + pivot=mid; + break; + } + queue.add(new int[]{q[0], mid}); + queue.add(new int[]{mid+1, q[1]}); + } + + int left = 0, right = nums.length-1; + if(target>=nums[0] && target<=nums[pivot]) { + right = pivot; + } else { + left = pivot+1; + } + + + while(left<=right){ + int mid = (left+right)/2; + if(target < nums[mid]) { + right=mid-1; + } else { + left=mid+1; + } + } + + if(nums[right] == target) { + return right; + } + + return -1; + } +} From 5f53f0207c8448f9dd80fe7da8f98b93b0bb3c48 Mon Sep 17 00:00:00 2001 From: minji-go Date: Thu, 19 Jun 2025 16:04:13 +0900 Subject: [PATCH 09/13] feat: merge-k-sorted-lists --- merge-k-sorted-lists/minji-go.java | 51 ++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+) create mode 100644 merge-k-sorted-lists/minji-go.java diff --git a/merge-k-sorted-lists/minji-go.java b/merge-k-sorted-lists/minji-go.java new file mode 100644 index 000000000..d0446a6db --- /dev/null +++ b/merge-k-sorted-lists/minji-go.java @@ -0,0 +1,51 @@ +/** + * week10-5. merge-k-sorted-lists + *
  • Description: Merge all the linked-lists into one sorted linked-list
    • + *
  • Topics: Linked List, Divide and Conquer, Heap (Priority Queue), Merge Sort
    • + *
  • Time Complexity: O(NlogK), Runtime 1ms
    • + *
  • Space Complexity: O(K), Memory 44.7MB
    • + */ +class Solution { + public ListNode mergeKLists(ListNode[] lists) { + if (lists == null || lists.length == 0) { + return null; + } + return mergeKLists(lists, 0, lists.length - 1); + } + + private ListNode mergeKLists(ListNode[] lists, int start, int end) { + if (start == end) { + return lists[start]; + } + + int mid = (start + end) / 2; + ListNode node1 = mergeKLists(lists, start, mid); + ListNode node2 = mergeKLists(lists, mid + 1, end); + return mergeTwoLists(node1, node2); + } + + private ListNode mergeTwoLists(ListNode node1, ListNode node2) { + ListNode dummy = new ListNode(-10_001); + ListNode merge = dummy; + + while (node1 != null && node2 != null) { + if (node1.val < node2.val) { + merge.next = node1; + merge = merge.next; + node1 = node1.next; + } else { + merge.next = node2; + merge = merge.next; + node2 = node2.next; + } + } + + if (node1 != null && node2 == null) { + merge.next = node1; + } else { + merge.next = node2; + } + + return dummy.next; + } +} From 3c8f1c8a58733789d6b69e5b1c63c689223da717 Mon Sep 17 00:00:00 2001 From: minji-go Date: Fri, 20 Jun 2025 16:35:53 +0900 Subject: [PATCH 10/13] feat: missing-number --- missing-number/minji-go.java | 25 +++++++++++-------------- 1 file changed, 11 insertions(+), 14 deletions(-) diff --git a/missing-number/minji-go.java b/missing-number/minji-go.java index 61cc2894f..933c149f8 100644 --- a/missing-number/minji-go.java +++ b/missing-number/minji-go.java @@ -1,19 +1,16 @@ -/* - Problem: https://leetcode.com/problems/missing-number/ - Description: return the only number in the range that is missing from the array. - Concept: Array, Hash Table, Math, Binary Search, Bit Manipulation, Sorting - Time Complexity: O(N), Runtime 0ms - Space Complexity: O(1), Memory 45.71MB -*/ +/** + * week11-1. missing-number + *
  • Description: Return the only number in the range that is missing from the array
    • + *
  • Topics: Array, Hash Table, Math, Binary Search, Bit Manipulation, Sorting
    • + *
  • Time Complexity: O(N), Runtime 0ms
    • + *
  • Space Complexity: O(1), Memory 45.67MB
    • + */ class Solution { public int missingNumber(int[] nums) { - int n = nums.length; - int missing = n; - - for(int i=0; i Date: Fri, 20 Jun 2025 16:36:00 +0900 Subject: [PATCH 11/13] feat: reorder-list --- reorder-list/minji-go.java | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 reorder-list/minji-go.java diff --git a/reorder-list/minji-go.java b/reorder-list/minji-go.java new file mode 100644 index 000000000..b99f6b77c --- /dev/null +++ b/reorder-list/minji-go.java @@ -0,0 +1,29 @@ +/** + * week11-2. reorder-list + *
  • Description: Reorder the list to be on the following form: L0 → Ln → L1 → Ln - 1 → L2 → ...
    • + *
  • Topics: Linked List, Two Pointers, Stack, Recursion
    • + *
  • Time Complexity: O(N), Runtime 5ms
    • + *
  • Space Complexity: O(N), Memory 47.96MB
    • + */ +class Solution { + public void reorderList(ListNode head) { + Deque deque = new ArrayDeque<>(); + + ListNode node = head; + while (node != null) { + deque.addLast(node); + node = node.next; + } + + ListNode curr = deque.removeFirst(); + while (!deque.isEmpty()) { + curr.next = deque.removeLast(); + curr = curr.next; + if (!deque.isEmpty()) { + curr.next = deque.removeFirst(); + curr = curr.next; + } + } + curr.next = null; + } +} From a3e16dd5e5a2aaef251f878189cf62f1464f0f05 Mon Sep 17 00:00:00 2001 From: minji-go Date: Fri, 20 Jun 2025 16:36:09 +0900 Subject: [PATCH 12/13] feat: merge-intervals --- merge-intervals/minji-go.java | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 merge-intervals/minji-go.java diff --git a/merge-intervals/minji-go.java b/merge-intervals/minji-go.java new file mode 100644 index 000000000..036a9bddd --- /dev/null +++ b/merge-intervals/minji-go.java @@ -0,0 +1,28 @@ +/** + * week11-4. merge-intervals + *
  • Description: return an array of the non-overlapping intervals
    • + *
  • Topics: Array, Sorting
    • + *
  • Time Complexity: O(NlogN), Runtime 10ms
    • + *
  • Space Complexity: O(N), Memory 46.18MB
    • + */ +class Solution { + public int[][] merge(int[][] intervals) { + Arrays.sort(intervals, (i1, i2) -> i1[0] - i2[0]); + + List merge = new ArrayList<>(); + merge.add(intervals[0]); + + for (int i = 1; i < intervals.length; i++) { + int[] prev = merge.get(merge.size() - 1); + int[] curr = intervals[i]; + + if (curr[0] <= prev[1]) { + prev[1] = Math.max(prev[1], curr[1]); + } else { + merge.add(curr); + } + } + + return merge.toArray(new int[merge.size()][]); + } +} From da93a18818530047bbe2559b64d648df6f4a0a91 Mon Sep 17 00:00:00 2001 From: minji-go Date: Fri, 20 Jun 2025 16:36:17 +0900 Subject: [PATCH 13/13] feat: binary-tree-maximum-path-sum --- binary-tree-maximum-path-sum/minji-go.java | 26 ++++++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 binary-tree-maximum-path-sum/minji-go.java diff --git a/binary-tree-maximum-path-sum/minji-go.java b/binary-tree-maximum-path-sum/minji-go.java new file mode 100644 index 000000000..7acc3c38a --- /dev/null +++ b/binary-tree-maximum-path-sum/minji-go.java @@ -0,0 +1,26 @@ +/** + * week11-5. binary-tree-maximum-path-sum + *
  • Description: Given the root of a binary tree, return the maximum path sum of any non-empty path
    • + *
  • Topics: Dynamic Programming, Tree, Depth-First Search, Binary Tree
    • + *
  • Time Complexity: O(N), Runtime 0ms
    • + *
  • Space Complexity: O(H), Memory 44.1MB
    • + */ +class Solution { + public int maxPathSum(TreeNode root) { + dfs(root); + return max; + } + + int max = Integer.MIN_VALUE; + public int dfs(TreeNode head) { + if (head == null) return 0; + + int left = Math.max(0, dfs(head.left)); + int right = Math.max(0, dfs(head.right)); + + max = Math.max(max, head.val + left + right); + + return head.val + Math.max(left, right); + } + +}