From d57d3349dbbc0846202c00ca6fd0fd04b71d167a Mon Sep 17 00:00:00 2001 From: forest000014 Date: Thu, 6 Mar 2025 00:14:34 +0900 Subject: [PATCH 1/5] DaleStudy#231 Meeting Rooms --- meeting-rooms/forest000014.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 meeting-rooms/forest000014.java diff --git a/meeting-rooms/forest000014.java b/meeting-rooms/forest000014.java new file mode 100644 index 000000000..56477d465 --- /dev/null +++ b/meeting-rooms/forest000014.java @@ -0,0 +1,15 @@ +/* +# Time Complexity: O(nlogn) +# Space Complexity: O(1) +*/ +class Solution { + public boolean canAttendMeetings(int[][] intervals) { + Arrays.sort(intervals, (a, b) -> a[0] - b[0]); + + for (int i = 1; i < intervals.length; i++) { + if (intervals[i][0] < intervals[i - 1][1]) return false; + } + + return true; + } +} From 43c4a66a430b9018532958c9026e5778bdd0428f Mon Sep 17 00:00:00 2001 From: forest000014 Date: Thu, 6 Mar 2025 00:15:03 +0900 Subject: [PATCH 2/5] DaleStudy#249 Lowest Common Ancestor of a Binary Search Tree --- .../forest000014.java | 28 +++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 lowest-common-ancestor-of-a-binary-search-tree/forest000014.java diff --git a/lowest-common-ancestor-of-a-binary-search-tree/forest000014.java b/lowest-common-ancestor-of-a-binary-search-tree/forest000014.java new file mode 100644 index 000000000..b40d1544f --- /dev/null +++ b/lowest-common-ancestor-of-a-binary-search-tree/forest000014.java @@ -0,0 +1,28 @@ +/* +# Time Complexity: O(n) +# Space Compleixty: O(1) +*/ + +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode(int x) { val = x; } + * } + */ + +class Solution { + public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { + // null check unnecessary + + if (root.val > p.val && root.val > q.val) { + return lowestCommonAncestor(root.left, p, q); + } else if (root.val < p.val && root.val < q.val) { + return lowestCommonAncestor(root.right, p, q); + } else { + return root; + } + } +} From 12171bc25ac4ec31ae27091015162cc73225a361 Mon Sep 17 00:00:00 2001 From: forest000014 Date: Thu, 6 Mar 2025 00:15:51 +0900 Subject: [PATCH 3/5] DaleStudy#252 Kth Smallest Element In a Bst --- .../forest000014.java | 53 +++++++++++++++++++ 1 file changed, 53 insertions(+) create mode 100644 kth-smallest-element-in-a-bst/forest000014.java diff --git a/kth-smallest-element-in-a-bst/forest000014.java b/kth-smallest-element-in-a-bst/forest000014.java new file mode 100644 index 000000000..c0ee7aea9 --- /dev/null +++ b/kth-smallest-element-in-a-bst/forest000014.java @@ -0,0 +1,53 @@ +/* +# Time Complexity: O(n) +# Space Complexity: O(n) + +heap을 사용한 풀이, in-order traversal을 사용한 풀이 풀어볼 것! +*/ +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode() {} + * TreeNode(int val) { this.val = val; } + * TreeNode(int val, TreeNode left, TreeNode right) { + * this.val = val; + * this.left = left; + * this.right = right; + * } + * } + */ +class Solution { + public int kthSmallest(TreeNode root, int k) { + Map sizes = new HashMap<>(); + + calculateSize(root, sizes); + + return findKth(root, k, sizes); + } + + private int calculateSize(TreeNode root, Map sizes) { + if (root == null) return 0; + + int left = calculateSize(root.left, sizes); + int right = calculateSize(root.right, sizes); + + sizes.put(root, left + right + 1); + return left + right + 1; + } + + private int findKth(TreeNode root, int k, Map sizes) { + int left = (root.left == null) ? 0 : sizes.get(root.left); + int right = (root.right == null) ? 0 : sizes.get(root.right); + + if (left == k - 1) { + return root.val; + } else if (left >= k) { + return findKth(root.left, k, sizes); + } else { + return findKth(root.right, k - left - 1, sizes); + } + } +} From 76d9a267f1d408e01a595f5f563179332c9e1e09 Mon Sep 17 00:00:00 2001 From: forest000014 Date: Thu, 6 Mar 2025 00:17:23 +0900 Subject: [PATCH 4/5] DaleStudy#289 Find Median from Data Stream --- .../forest000014.java | 49 +++++++++++++++++++ 1 file changed, 49 insertions(+) create mode 100644 find-median-from-data-stream/forest000014.java diff --git a/find-median-from-data-stream/forest000014.java b/find-median-from-data-stream/forest000014.java new file mode 100644 index 000000000..e7f3f76c9 --- /dev/null +++ b/find-median-from-data-stream/forest000014.java @@ -0,0 +1,49 @@ +/* +# Time Complexity: O(nlogn) +# Space Complexity: O(nlogn) + +*/ +class MedianFinder { + + private PriorityQueue pq1; // 1번째 ~ 가운데 원소 (max heap) + private PriorityQueue pq2; // 가운데+1번째 ~ 마지막 원소 (min heap) + + public MedianFinder() { + pq1 = new PriorityQueue<>(Collections.reverseOrder()); + pq2 = new PriorityQueue<>(); + } + + public void addNum(int num) { + + if (pq1.size() == pq2.size()) { + if (pq1.peek() == null || pq1.peek() >= num) { + pq1.add(num); + } else { + pq2.add(num); + pq1.add(pq2.poll()); + } + } else { + if (pq1.peek() == null || pq1.peek() >= num) { + pq1.add(num); + pq2.add(pq1.poll()); + } else { + pq2.add(num); + } + } + } + + public double findMedian() { + if (pq1.size() == pq2.size()) { + return (pq1.peek() + pq2.peek()) / 2.0; + } else { + return pq1.peek(); + } + } +} + +/** + * Your MedianFinder object will be instantiated and called as such: + * MedianFinder obj = new MedianFinder(); + * obj.addNum(num); + * double param_2 = obj.findMedian(); + */ From 2dc08273fe40c944fc00e631a6471e2adc5acf45 Mon Sep 17 00:00:00 2001 From: forest000014 Date: Thu, 6 Mar 2025 23:43:53 +0900 Subject: [PATCH 5/5] DaleStudy#277 Insert Interval --- insert-interval/forest000014.java | 34 +++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) create mode 100644 insert-interval/forest000014.java diff --git a/insert-interval/forest000014.java b/insert-interval/forest000014.java new file mode 100644 index 000000000..0488e75d3 --- /dev/null +++ b/insert-interval/forest000014.java @@ -0,0 +1,34 @@ +/* +# Time Complexity: O(n) +# Space Complexity: O(1) +*/ +class Solution { + public int[][] insert(int[][] intervals, int[] newInterval) { + ArrayList answer = new ArrayList<>(); + + int i = 0; + int n = intervals.length; + + // newInterval보다 왼쪽의 구간들 추가 + while (i < n && intervals[i][1] < newInterval[0]) { + answer.add(intervals[i]); + i++; + } + + // newInterval과 겹치는 구간들 병합 + while (i < n && intervals[i][0] <= newInterval[1]) { + newInterval[0] = Math.min(newInterval[0], intervals[i][0]); + newInterval[1] = Math.max(newInterval[1], intervals[i][1]); + i++; + } + answer.add(newInterval); + + // newInterval보다 오른쪽의 구간들 추가 + while (i < n) { + answer.add(intervals[i]); + i++; + } + + return answer.toArray(new int[answer.size()][]); + } +}