Update

Author: ex01tus

src/binary_tree/BinaryTreePostorderTraversal.java

@@ -22,7 +22,7 @@ public List<Integer> postorderTraversalViaTwoStacks(TreeNode root) {
 
         stack.push(root);
         while (!stack.isEmpty()) {
-            TreeNode current = stack.poll();
+            TreeNode current = stack.pop();
             out.push(current);
 
             if (current.left != null) stack.push(current.left);

src/binary_tree/CountGoodNodesInBinaryTree.java

@@ -0,0 +1,32 @@
+package binary_tree;
+
+/**
+ * Description: https://leetcode.com/problems/count-good-nodes-in-binary-tree
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(h)
+ */
+public class CountGoodNodesInBinaryTree {
+
+    public int goodNodes(TreeNode root) {
+        return count(root, Integer.MIN_VALUE);
+    }
+
+    private int count(TreeNode root, int max) {
+        if (root == null) return 0;
+
+        max = Math.max(root.val, max);
+
+        int current = root.val >= max ? 1 : 0;
+        int left = count(root.left, max);
+        int right = count(root.right, max);
+
+        return current + left + right;
+    }
+
+    private static class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+    }
+}

src/binary_tree/SumRootToLeafNodes.java

@@ -0,0 +1,31 @@
+package binary_tree;
+
+/**
+ * Description: https://leetcode.com/problems/sum-root-to-leaf-numbers
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(h)
+ */
+public class SumRootToLeafNodes {
+
+    public int sumNumbers(TreeNode root) {
+        return sum(root, 0);
+    }
+
+    private int sum(TreeNode root, int sum) {
+        if (root == null) return 0;
+
+        sum = sum * 10 + root.val;
+        if (root.left == null && root.right == null) {
+            return sum;
+        }
+
+        return sum(root.left, sum) + sum(root.right, sum);
+    }
+
+    private static class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+    }
+}

src/graph/CourseSchedule2.java

@@ -48,7 +48,7 @@ private boolean hasCycle(Map<Integer, List<Integer>> adjList, int start) {
         stack.push(start);
 
         while (!stack.isEmpty()) {
-            int current = stack.poll();
+            int current = stack.pop();
 
             if (visited[current] == 0) {
                 visited[current] = 1;

src/graph/MaxAreaOfIsland.java

@@ -37,7 +37,7 @@ private int dfs(int[][] grid, int[] start) {
 
         int count = 0;
         while (!stack.isEmpty()) {
-            int[] current = stack.poll();
+            int[] current = stack.pop();
 
             if (visited[current[0]][current[1]] == 0) {
                 visited[current[0]][current[1]] = 1;

src/graph/PacificAtlanticWaterFlow.java

@@ -49,7 +49,7 @@ private void dfs(int[][] heights, int[][] visited, int[] start) {
         stack.push(start);
 
         while (!stack.isEmpty()) {
-            int[] current = stack.poll();
+            int[] current = stack.pop();
 
             if (visited[current[0]][current[1]] == 0) {
                 stack.push(current);
@@ -100,7 +100,7 @@ private boolean canFlowBothWays(int[][] heights, int[] start) {
         stack.push(start);
 
         while (!stack.isEmpty()) {
-            int[] current = stack.poll();
+            int[] current = stack.pop();
 
             if (visited[current[0]][current[1]] == 0) {
                 visited[current[0]][current[1]] = 1;

src/graph/SurroundedRegions.java

@@ -47,7 +47,7 @@ private boolean isSurrounded(char[][] board, int[] start, int component) {
 
         boolean isSurrounded = true;
         while (!stack.isEmpty()) {
-            int[] current = stack.poll();
+            int[] current = stack.pop();
 
             if (visited[current[0]][current[1]] == 0) {
                 visited[current[0]][current[1]] = 1;

src/graph/WordSearch.java

@@ -42,7 +42,7 @@ private boolean isExist(char[][] board, String word, int[] start) {
                 return true;
             }
 
-            int[] current = stack.poll();
+            int[] current = stack.pop();
 
             if (visited[current[0]][current[1]] == 0) {
                 if (board[current[0]][current[1]] != word.charAt(pointer)) {

src/array/InsertInterval.java renamed to src/interval/InsertInterval.java

@@ -1,4 +1,4 @@
-package array;
+package interval;
 
 import java.util.ArrayList;
 import java.util.List;

src/interval/IntervalListIntersections.java

@@ -0,0 +1,39 @@
+package interval;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Description: https://leetcode.com/problems/interval-list-intersections
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ */
+public class IntervalListIntersections {
+
+    public int[][] intervalIntersection(int[][] firstList, int[][] secondList) {
+        List<int[]> intersections = new ArrayList<>();
+
+        int firstPointer = 0;
+        int secondPointer = 0;
+
+        while (firstPointer < firstList.length && secondPointer < secondList.length) {
+            int[] firstInterval = firstList[firstPointer];
+            int[] secondInterval = secondList[secondPointer];
+
+            if (firstInterval[0] <= secondInterval[1] && secondInterval[0] <= firstInterval[1]) {
+                intersections.add(new int[]{
+                        Math.max(firstInterval[0], secondInterval[0]),
+                        Math.min(firstInterval[1], secondInterval[1])});
+            }
+
+            if (firstInterval[1] < secondInterval[1]) {
+                firstPointer++;
+            } else {
+                secondPointer++;
+            }
+        }
+
+        return intersections.toArray(new int[0][]);
+    }
+}

src/array/MeetingRooms.java renamed to src/interval/MeetingRooms.java

@@ -1,4 +1,4 @@
-package array;
+package interval;
 
 import java.util.Arrays;
 import java.util.Comparator;

src/interval/MeetingRooms2.java

@@ -0,0 +1,49 @@
+package interval;
+
+import java.util.Arrays;
+
+/**
+ * Description: https://leetcode.com/problems/meeting-rooms-ii
+ * Difficulty: Medium
+ * Time complexity: O(nlog n)
+ * Space complexity: O(n)
+ */
+public class MeetingRooms2 {
+
+    public int minMeetingRooms(Interval[] intervals) {
+        int[] starts = new int[intervals.length];
+        int[] ends = new int[intervals.length];
+
+        for (int i = 0; i < intervals.length; i++) {
+            starts[i] = intervals[i].start;
+            ends[i] = intervals[i].end;
+        }
+
+        Arrays.sort(starts);
+        Arrays.sort(ends);
+
+        int startPointer = 0;
+        int endPointer = 0;
+        int busyRoomsCount = 0;
+        int maxCount = 0;
+
+        while (startPointer < starts.length) {
+            if (starts[startPointer] < ends[endPointer]) { // a new meeting has started, while the previous one didn't end
+                busyRoomsCount++;
+                startPointer++;
+            } else { // a meeting has ended
+                busyRoomsCount--;
+                endPointer++;
+            }
+
+            maxCount = Math.max(busyRoomsCount, maxCount);
+        }
+
+        return maxCount;
+    }
+
+    private static class Interval {
+        int start;
+        int end;
+    }
+}

src/array/MergeIntervals.java renamed to src/interval/MergeIntervals.java

@@ -1,4 +1,4 @@
-package array;
+package interval;
 
 import java.util.ArrayList;
 import java.util.Arrays;

src/interval/MinimumNumberOfArrowsToBurstBalloons.java

@@ -0,0 +1,32 @@
+package interval;
+
+import java.util.Arrays;
+
+/**
+ * Description: https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons
+ * Difficulty: Medium
+ * Time complexity: O(nlog n)
+ * Space complexity: O(1)
+ */
+public class MinimumNumberOfArrowsToBurstBalloons {
+
+    public int findMinArrowShots(int[][] points) {
+        if (points.length < 2) return points.length;
+
+        Arrays.sort(points, (p1, p2) -> Integer.compare(p1[0], p2[0]));
+
+        int end = points[0][1];
+        int nonOverlapingIntervals = 1;
+
+        for (int[] point : points) {
+            if (point[0] > end) {
+                nonOverlapingIntervals++;
+                end = point[1];
+            } else {
+                end = Math.min(end, point[1]);
+            }
+        }
+
+        return nonOverlapingIntervals;
+    }
+}

src/interval/NonOverlappingIntervals.java

@@ -0,0 +1,31 @@
+package interval;
+
+import java.util.Arrays;
+
+/**
+ * Description: https://leetcode.com/problems/non-overlapping-intervals
+ * Difficulty: Medium
+ * Time complexity: O(nlog n)
+ * Space complexity: O(1)
+ */
+public class NonOverlappingIntervals {
+
+    public int eraseOverlapIntervals(int[][] intervals) {
+        if (intervals.length < 2) return 0;
+
+        Arrays.sort(intervals, (i1, i2) -> Integer.compare(i1[0], i2[0]));
+
+        int end = intervals[0][1];
+        int nonOverlappingIntervals = 1;
+        for (int[] current : intervals) {
+            if (current[0] >= end) {
+                nonOverlappingIntervals++;
+                end = current[1];
+            } else {
+                end = Math.min(end, current[1]);
+            }
+        }
+
+        return intervals.length - nonOverlappingIntervals;
+    }
+}

src/stack/MinStack.java

@@ -40,10 +40,10 @@ private static class Node {
             Node next;
             int min;
 
-            public Node(int v, Node n, int m) {
-                val = v;
-                next = n;
-                min = m;
+            public Node(int val, Node node, int min) {
+                this.val = val;
+                this.next = node;
+                this.min = min;
             }
         }
     }