Update

Author: ex01tus

src/array/IntersectionOfTwoArrays.java

@@ -0,0 +1,61 @@
+package array;
+
+import java.util.*;
+
+/**
+ * Description: https://leetcode.com/problems/intersection-of-two-arrays
+ * Difficulty: Easy
+ */
+public class IntersectionOfTwoArrays {
+
+    /**
+     * Time complexity: O(m + n)
+     * Space complexity: O(min(m, n))
+     */
+    public int[] intersectionViaSet(int[] small, int[] large) {
+        if (small.length > large.length) {
+            return intersectionViaSet(large, small);
+        }
+
+        Set<Integer> smallSet = new HashSet<>();
+        for (int num : small) {
+            smallSet.add(num);
+        }
+
+        List<Integer> intersection = new ArrayList<>();
+        for (int num : large) {
+            if (smallSet.remove(num)) {
+                intersection.add(num);
+            }
+        }
+
+        return intersection.stream().mapToInt(v -> v).toArray();
+    }
+
+    /**
+     * Time complexity: O(nlog n + mlog m)
+     * Space complexity: O(log n + log m)
+     */
+    public int[] intersectionViaSorting(int[] nums1, int[] nums2) {
+        Arrays.sort(nums1);
+        Arrays.sort(nums2);
+
+        int first = 0;
+        int second = 0;
+
+        Set<Integer> intersection = new HashSet<>();
+        while (first < nums1.length && second < nums2.length) {
+            if (nums1[first] > nums2[second]) {
+                second++;
+            } else if (nums1[first] < nums2[second]) {
+                first++;
+            } else {
+                intersection.add(nums1[first]);
+                first++;
+                second++;
+            }
+        }
+
+        return intersection.stream().mapToInt(v -> v).toArray();
+    }
+}

src/array/IntersectionOfTwoArrays2.java

@@ -0,0 +1,69 @@
+package array;
+
+import java.util.*;
+
+/**
+ * Description: https://leetcode.com/problems/intersection-of-two-arrays-ii
+ * Difficulty: Easy
+ */
+public class IntersectionOfTwoArrays2 {
+
+    /**
+     * Time complexity: O(m + n)
+     * Space complexity: O(min(m, n))
+     */
+    public int[] intersectViaFreqMap(int[] small, int[] large) {
+        if (small.length > large.length) {
+            return intersectViaFreqMap(large, small); // to save memory on freqMap
+        }
+
+        Map<Integer, Integer> freqMap = buildFrequencyMap(small);
+        List<Integer> intersection = new ArrayList<>();
+        for (int num : large) {
+            int count = freqMap.getOrDefault(num, 0);
+            if (count > 0) {
+                intersection.add(num);
+                freqMap.merge(num, -1, Integer::sum);
+            }
+        }
+
+        return intersection.stream().mapToInt(v -> v).toArray();
+    }
+
+    private Map<Integer, Integer> buildFrequencyMap(int[] nums) {
+        Map<Integer, Integer> freqMap = new HashMap<>();
+        for (int num : nums) {
+            freqMap.merge(num, 1, Integer::sum);
+        }
+
+        return freqMap;
+    }
+
+    /**
+     * Time complexity: O(nlog n + mlog m)
+     * Space complexity: O(log n + log m)
+     */
+    public int[] intersectViaSorting(int[] nums1, int[] nums2) {
+        Arrays.sort(nums1);
+        Arrays.sort(nums2);
+
+        int first = 0;
+        int second = 0;
+
+        List<Integer> intersection = new ArrayList<>();
+        while (first < nums1.length && second < nums2.length) {
+            if (nums1[first] > nums2[second]) {
+                second++;
+            } else if (nums1[first] < nums2[second]) {
+                first++;
+            } else {
+                intersection.add(nums1[first]);
+                first++;
+                second++;
+            }
+        }
+
+
+        return intersection.stream().mapToInt(v -> v).toArray();
+    }
+}

src/array/TwoSum.java

@@ -13,13 +13,12 @@ public class TwoSum {
 
     public int[] twoSum(int[] nums, int target) {
         Map<Integer, Integer> seen = new HashMap<>();
-        seen.put(nums[0], 0);
 
-        for (int i = 1; i < nums.length; i++) {
-            int pair = target - nums[i];
-            Integer pairIndex = seen.get(pair);
-            if (pairIndex != null) {
-                return new int[]{i, pairIndex};
+        for (int i = 0; i < nums.length; i++) {
+            int possiblePair = target - nums[i];
+            Integer possiblePairIndex = seen.get(possiblePair);
+            if (possiblePairIndex != null) {
+                return new int[] {i, possiblePairIndex};
             }
 
             seen.put(nums[i], i);

src/binary/PowerOfTwo.java

@@ -0,0 +1,26 @@
+package binary;
+
+/**
+ * Description: https://leetcode.com/problems/power-of-two
+ * Difficulty: Easy
+ */
+public class PowerOfTwo {
+
+    /**
+     * Time complexity: O(1)
+     * Space complexity: O(1)
+     */
+    public boolean isPowerOfTwoViaBitManipulation(int n) {
+        // 4 = 100; 4 - 1 = 3 = 11; 100 & 11 = 0
+        // 8 = 1000; 8 - 1 = 7 = 111; 1000 & 111 = 0
+        return n > 0 && (n & (n - 1)) == 0;
+    }
+
+    /**
+     * Time complexity: O(log n)
+     * Space complexity: O(log n)
+     */
+    public boolean isPowerOfTwoViaBaseConversion(int n) {
+        return Integer.toString(n, 2).matches("^10*$");
+    }
+}

src/binary_search_tree/InorderSuccessorInBST.java

@@ -0,0 +1,49 @@
+package binary_search_tree;
+
+/**
+ * Description: https://leetcode.com/problems/inorder-successor-in-bst
+ * Difficulty: Medium
+ */
+public class InorderSuccessorInBST {
+
+    /**
+     * Time complexity: O(h)
+     * Space complexity: O(1)
+     */
+    public TreeNode inorderSuccessorViaIteration(TreeNode root, TreeNode p) {
+        TreeNode successor = null;
+
+        while (root != null) {
+            if (p.val >= root.val) {
+                root = root.right;
+            } else {
+                successor = root;
+                root = root.left;
+            }
+        }
+
+        return successor;
+    }
+
+    /**
+     * Time complexity: O(h)
+     * Space complexity: O(h)
+     */
+    public TreeNode inorderSuccessorViaRecursion(TreeNode root, TreeNode p) {
+        return find(root, null, p);
+    }
+
+    private TreeNode find(TreeNode current, TreeNode parent, TreeNode p) {
+        if (current == null) return parent;
+
+        return p.val >= current.val
+                ? find(current.right, parent, p)
+                : find(current.left, current, p);
+    }
+
+    private static class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+    }
+}

src/graph/AsFarFromLandAsPossible.java

@@ -0,0 +1,54 @@
+package graph;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * Description: https://leetcode.com/problems/as-far-from-land-as-possible
+ * Difficulty: Medium
+ * Time complexity: O(m * n)
+ * Space complexity: O(m * n)
+ */
+public class AsFarFromLandAsPossible {
+
+    public int maxDistance(int[][] grid) {
+        int[][] visited = new int[grid.length][grid[0].length];
+        int[][] directions = new int[][]{{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+
+        Queue<int[]> planned = new LinkedList<>();
+        for (int i = 0; i < grid.length; i++) {
+            for (int j = 0; j < grid[0].length; j++) {
+                if (grid[i][j] == 1) {
+                    visited[i][j] = 1;
+                    planned.offer(new int[]{i, j});
+                }
+            }
+        }
+
+        // no land cells or no water cells
+        if (planned.isEmpty() || planned.size() == grid.length * grid[0].length) {
+            return -1;
+        }
+
+        int distance = 0;
+        while (!planned.isEmpty()) {
+            int levelSize = planned.size();
+            distance++;
+
+            for (int i = 0; i < levelSize; i++) {
+                int[] current = planned.poll();
+                for (int[] dir : directions) {
+                    int x = current[0] + dir[0];
+                    int y = current[1] + dir[1];
+                    if (x >= 0 && x < grid.length && y >= 0 && y < grid[0].length
+                            && visited[x][y] == 0) {
+                        visited[x][y] = 1;
+                        planned.offer(new int[]{x, y});
+                    }
+                }
+            }
+        }
+
+        return distance - 1;
+    }
+}

src/graph/CountSubIslands.java

@@ -0,0 +1,46 @@
+package graph;
+
+/**
+ * Description: https://leetcode.com/problems/count-sub-islands
+ * Difficulty: Medium
+ * Time complexity: O(m * n)
+ * Space complexity: O(m * n)
+ */
+public class CountSubIslands {
+
+    private final int[][] directions = new int[][]{{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+
+    public int countSubIslands(int[][] grid1, int[][] grid2) {
+        int[][] visited = new int[grid2.length][grid2[0].length];
+        int subIslands = 0;
+        for (int i = 0; i < grid2.length; i++) {
+            for (int j = 0; j < grid2[0].length; j++) {
+                if (grid2[i][j] == 1 && visited[i][j] == 0 && isSubIsland(grid1, grid2, visited, i, j)) {
+                    subIslands++;
+                }
+            }
+        }
+
+        return subIslands;
+    }
+
+    private boolean isSubIsland(int[][] grid1, int[][] grid2, int[][] visited, int x, int y) {
+        if (grid1[x][y] != 1) return false;
+
+        visited[x][y] = 1;
+        boolean isSubIsland = true;
+        for (int[] dir : directions) {
+            int x1 = x + dir[0];
+            int y1 = y + dir[1];
+
+            if (x1 >= 0 && x1 < grid2.length && y1 >= 0 && y1 < grid2[0].length
+                    && visited[x1][y1] == 0 && grid2[x1][y1] == 1) {
+                if (!isSubIsland(grid1, grid2, visited, x1, y1)) {
+                    isSubIsland = false;
+                }
+            }
+        }
+
+        return isSubIsland;
+    }
+}

src/graph/FloodFill.java

@@ -3,8 +3,8 @@
 /**
  * Description: https://leetcode.com/problems/flood-fill
  * Difficulty: Easy
- * Time complexity: O(n)
- * Space complexity: O(n)
+ * Time complexity: O(m * n)
+ * Space complexity: O(m * n)
  */
 public class FloodFill {
 

src/graph/NumberOfClosedIslands.java

@@ -0,0 +1,46 @@
+package graph;
+
+/**
+ * Description: https://leetcode.com/problems/number-of-closed-islands
+ * Difficulty: Medium
+ * Time complexity: O(m * n)
+ * Space complexity: O(m * n)
+ */
+public class NumberOfClosedIslands {
+
+    private final int[][] directions = new int[][]{{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+
+    public int closedIsland(int[][] grid) {
+        int[][] visited = new int[grid.length][grid[0].length];
+
+        int closedIslands = 0;
+        for (int i = 0; i < grid.length; i++) {
+            for (int j = 0; j < grid[0].length; j++) {
+                if (grid[i][j] == 0 && visited[i][j] == 0 && isClosed(grid, visited, i, j)) {
+                    closedIslands++;
+                }
+            }
+        }
+
+        return closedIslands;
+    }
+
+    private boolean isClosed(int[][] grid, int[][] visited, int x, int y) {
+        if (grid[x][y] == 1 || visited[x][y] == 1) {
+            return true;
+        }
+
+        visited[x][y] = 1;
+        boolean isClosed = true;
+        for (int[] dir : directions) {
+            int x1 = x + dir[0];
+            int y1 = y + dir[1];
+            if (x1 < 0 || x1 >= grid.length || y1 < 0 || y1 >= grid[0].length
+                    || !isClosed(grid, visited, x1, y1)) {
+                isClosed = false;
+            }
+        }
+
+        return isClosed;
+    }
+}