Update

Author: ex01tus

src/array/FirstMissingPositive.java

@@ -0,0 +1,64 @@
+package array;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Description: https://leetcode.com/problems/first-missing-positive
+ * Difficulty: Hard
+ */
+public class FirstMissingPositive {
+
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(1)
+     */
+    public int firstMissingPositiveOptimalApproach(int[] nums) {
+        int n = nums.length;
+
+        // first missing positive is either in range [1, n] or equal to n + 1
+        for (int i = 0; i < n; i++) {
+            // "kill" all non-positive values
+            if (nums[i] <= 0) nums[i] = n + 1;
+        }
+
+        // use array as hashtable
+        // if number exists in an array mark its index (0-indexed) with negative value
+        // [3, 4, 5, 1]
+        // 3 exists -> [3, 4, -5, 1]
+        // 4 exists -> [3, 4, -5, -1]
+        // 5 is greater than n -> not interested
+        // 1 exists -> [-1, 4, -5, -1]
+        for (int i = 0; i < n; i++) {
+            int num = Math.abs(nums[i]);
+            if (num > n) continue;
+
+            nums[num - 1] = -Math.abs(nums[num - 1]);
+        }
+
+        // [-1, 4, -5, -1] -> first non-negative value is 4 with index 2 (1-indexed) -> 2
+        for (int i = 0; i < n; i++) {
+            if (nums[i] > 0) return i + 1;
+        }
+
+        // if all values are negative -> original array is e.g. [1, 2, 3, 4] -> 5
+        return n + 1;
+    }
+
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    public int firstMissingPositiveNaiveApproach(int[] nums) {
+        Set<Integer> seen = new HashSet<>();
+        for (int num : nums) {
+            if (num > 0) seen.add(num);
+        }
+
+        for (int num = 1; num < Integer.MAX_VALUE; num++) {
+            if (!seen.contains(num)) return num;
+        }
+
+        return -1;
+    }
+}

src/array/NextPermutation.java

@@ -0,0 +1,49 @@
+package array;
+
+/**
+ * Description: https://leetcode.com/problems/next-permutation
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(1)
+ */
+public class NextPermutation {
+
+    public void nextPermutation(int[] nums) {
+        int firstDecreasing = nums.length - 2;
+        // 1 5 8 [4] 7 6 5 3 1
+        while (firstDecreasing >= 0
+                && nums[firstDecreasing] >= nums[firstDecreasing + 1]) {
+            firstDecreasing--;
+        }
+
+        if (firstDecreasing >= 0) {
+            // 1 5 8 [4] 7 6 [5] 3 1
+            int firstGreater = nums.length - 1;
+            while (nums[firstGreater] <= nums[firstDecreasing]) {
+                firstGreater--;
+            }
+
+            // 1 5 8 [4] 7 6 [5] 3 1 -> 1 5 8 [5] 7 6 [4] 3 1
+            swap(nums, firstDecreasing, firstGreater);
+        }
+
+        // 1 5 8 5 [7 6 4 3 1] -> 1 5 8 5 [1 3 4 6 7]
+        reverseStartingFrom(nums, firstDecreasing + 1);
+    }
+
+    private void reverseStartingFrom(int[] nums, int start) {
+        int left = start;
+        int right = nums.length - 1;
+        while (left < right) {
+            swap(nums, left, right);
+            left++;
+            right--;
+        }
+    }
+
+    private void swap(int[] nums, int i, int j) {
+        int tmp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = tmp;
+    }
+}

src/binary/BitwiseAndOfNumbersRange.java

@@ -0,0 +1,46 @@
+package binary;
+
+/**
+ * Description: https://leetcode.com/problems/bitwise-and-of-numbers-range
+ * Difficulty: Medium
+ */
+public class BitwiseAndOfNumbersRange {
+
+    /**
+     * Time complexity: O(1)
+     * Space complexity: O(1)
+     */
+    public int rangeBitwiseAndViaCommonPrefix(int left, int right) {
+        // Result of an AND operation on range is a common prefix with the rest of the bits as zeroes
+        //  9 = [00001] 001
+        // 10 = [00001] 010
+        // 11 = [00001] 011
+        // 12 = [00001] 100
+        // ----------------
+        // &    [00001] 000
+
+        int shift = 0;
+        while (left != right) {
+            // shift to the right, until common prefix is found
+            left = left >> 1;
+            right = right >> 1;
+            shift++;
+        }
+
+        // shift to the left to place an appropriate amount of zero bits
+        return left << shift;
+    }
+
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(1)
+     */
+    public int rangeBitwiseAndNaiveApproach(int left, int right) {
+        int result = left;
+        for (int i = left + 1; i <= right; i++) {
+            result &= i;
+        }
+
+        return result;
+    }
+}

src/binary_search/KokoEatingBananas.java

@@ -17,7 +17,7 @@ public int minEatingSpeed(int[] piles, int hours) {
             int midSpeed = minSpeed + (maxSpeed - minSpeed) / 2;
 
             if (canEatAllBananas(piles, hours, midSpeed)) {
-                min = Math.min(min, midSpeed);
+                min = midSpeed;
                 maxSpeed = midSpeed - 1;
             } else {
                 minSpeed = midSpeed + 1;

src/binary_search/MaximumCandiesAllocatedToKChildren.java

@@ -20,7 +20,7 @@ public int maximumCandies(int[] candies, long children) {
             int midAllocation = minAllocation + (maxAllocation - minAllocation) / 2;
 
             if (canAllocateCandyToEveryChild(candies, children, midAllocation)) {
-                max = Math.max(max, midAllocation);
+                max = minAllocation;
                 minAllocation = midAllocation + 1;
             } else {
                 maxAllocation = midAllocation - 1;

src/binary_search/MedianOfTwoSortedArrays.java

@@ -3,14 +3,16 @@
 /**
  * Description: https://leetcode.com/problems/median-of-two-sorted-arrays
  * Difficulty: Hard
- * Time complexity: O(log min(m, n))
- * Space complexity: O(1)
  */
 public class MedianOfTwoSortedArrays {
 
-    public double findMedianSortedArraysV1(int[] small, int[] large) {
+    /**
+     * Time complexity: O(log min(m, n))
+     * Space complexity: O(1)
+     */
+    public double findMedianSortedArraysViaBinarySearchV1(int[] small, int[] large) {
         if (small.length > large.length) {
-            return findMedianSortedArraysV1(large, small);
+            return findMedianSortedArraysViaBinarySearchV1(large, small);
         }
 
         int total = small.length + large.length;
@@ -43,9 +45,13 @@ public double findMedianSortedArraysV1(int[] small, int[] large) {
         throw new RuntimeException();
     }
 
-    public double findMedianSortedArraysV2(int[] small, int[] large) {
+    /**
+     * Time complexity: O(log min(m, n))
+     * Space complexity: O(1)
+     */
+    public double findMedianSortedArraysViaBinarySearchV2(int[] small, int[] large) {
         if (small.length > large.length) {
-            return findMedianSortedArraysV2(large, small);
+            return findMedianSortedArraysViaBinarySearchV2(large, small);
         }
 
         int total = small.length + large.length;
@@ -72,4 +78,41 @@ public double findMedianSortedArraysV2(int[] small, int[] large) {
 
         throw new RuntimeException();
     }
+
+    /**
+     * Time complexity: O(m + n)
+     * Space complexity: O(m + n)
+     */
+    public double findMedianSortedArraysViaMerge(int[] first, int[] second) {
+        int[] merged = merge(first, second);
+        int length = merged.length;
+        return length % 2 == 0
+                ? (merged[length / 2 - 1] + merged[length / 2]) / 2.0
+                : (double) merged[length / 2];
+    }
+
+    private int[] merge(int[] first, int[] second) {
+        int[] merged = new int[first.length + second.length];
+
+        int i = 0;
+        int j = 0;
+        int k = 0;
+        while (i < first.length && j < second.length) {
+            if (first[i] <= second[j]) {
+                merged[k++] = first[i++];
+            } else {
+                merged[k++] = second[j++];
+            }
+        }
+
+        while (i < first.length) {
+            merged[k++] = first[i++];
+        }
+
+        while (j < second.length) {
+            merged[k++] = second[j++];
+        }
+
+        return merged;
+    }
 }

src/binary_tree/InsufficientNodesInRootToLeafPaths.java

@@ -0,0 +1,39 @@
+package binary_tree;
+
+/**
+ * Description: https://leetcode.com/problems/insufficient-nodes-in-root-to-leaf-paths
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(h)
+ */
+public class InsufficientNodesInRootToLeafPaths {
+
+    public TreeNode sufficientSubset(TreeNode root, int limit) {
+        return removeInsufficientNodes(root, 0, limit);
+    }
+
+    private TreeNode removeInsufficientNodes(TreeNode root, int currentPathSum, int limit) {
+        if (root == null) return null;
+
+        if (isLeaf(root)) {
+            // remove insufficient leaf
+            return currentPathSum + root.val >= limit ? root : null;
+        }
+
+        root.left = removeInsufficientNodes(root.left, currentPathSum + root.val, limit);
+        root.right = removeInsufficientNodes(root.right, currentPathSum + root.val, limit);
+
+        // if node became a leaf -> all the paths through it were insufficient -> remove it
+        return isLeaf(root) ? null : root;
+    }
+
+    private boolean isLeaf(TreeNode root) {
+        return root.left == null && root.right == null;
+    }
+
+    private static class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+    }
+}

src/binary_tree/MaximumLevelSumOfBinaryTree.java

@@ -0,0 +1,47 @@
+package binary_tree;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * Description: https://leetcode.com/problems/maximum-level-sum-of-a-binary-tree
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ */
+public class MaximumLevelSumOfBinaryTree {
+
+    public int maxLevelSum(TreeNode root) {
+        Queue<TreeNode> planned = new LinkedList<>();
+        planned.offer(root);
+
+        int maxSum = Integer.MIN_VALUE;
+        int maxLevel = 0;
+        int currentLevel = 0;
+        while (!planned.isEmpty()) {
+            int levelSize = planned.size();
+            int levelSum = 0;
+            currentLevel++;
+            for (int i = 0; i < levelSize; i++) {
+                TreeNode current = planned.poll();
+                levelSum += current.val;
+
+                if (current.left != null) planned.offer(current.left);
+                if (current.right != null) planned.offer(current.right);
+            }
+
+            if (levelSum > maxSum) {
+                maxSum = levelSum;
+                maxLevel = currentLevel;
+            }
+        }
+
+        return maxLevel;
+    }
+
+    private static class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+    }
+}