Merge pull request ByteByteGoHq#30 from Jer3myYu/java-solutions-binary-search

Java Chapter 6: Binary Search

Author: Destiny-02

java/Binary Search/CuttingWood.java

@@ -0,0 +1,31 @@
+import java.util.Arrays;
+
+public class CuttingWood {
+    public int cuttingwood(int[] heights, int k) {
+        int left = 0;
+        int right = Arrays.stream(heights).max().getAsInt();
+        while (left < right) {
+            // Bias the midpoint to the right during the upper-bound binary 
+            // search.
+            int mid = left + (right - left) / 2 + 1;
+            if (cutsEnoughWood(mid, k, heights)) {
+                left = mid;
+            } else {
+                right = mid - 1;
+            }
+        }
+        return right;
+    }
+
+    // Determine if the current value of 'H' cuts at least 'k' meters of 
+    // wood.
+    private boolean cutsEnoughWood(int H, int k, int[] heights) {
+        int woodCollected = 0;
+        for (int height : heights) {
+            if (height > H) {
+                woodCollected += (height - H);
+            }
+        }
+        return woodCollected >= k;
+    }
+}

java/Binary Search/FindTheInsertionIndex.java

@@ -0,0 +1,20 @@
+public class FindTheInsertionIndex {
+    public int findTheInsertionIndex(int[] nums, int target) {
+        int left = 0;
+        int right = nums.length;
+        while (left < right) {
+            int mid = left + (right - left) / 2;
+            // If the midpoint value is greater than or equal to the target, 
+            // the lower bound is either at the midpoint, or to its left.
+            if (nums[mid] >= target) {
+                right = mid;
+            }
+            // The midpoint value is less than the target, indicating the 
+            // lower bound is somewhere to the right.
+            else {
+                left = mid + 1;
+            }
+        }
+        return left;
+    }
+}

java/Binary Search/FindTheMedianFromTwoSortedArrays.java

@@ -0,0 +1,49 @@
+import java.util.Set;
+
+public class FindTheMedianFromTwoSortedArrays {
+    public float findTheMedianFromTwoSortedArrays(int[] nums1, int[] nums2) {
+        // Optimization: ensure 'nums1' is the smaller array.
+        if (nums2.length < nums1.length) {
+            int[] tmp = nums1;
+            nums1 = nums2;
+            nums2 = tmp;
+        }
+        int m = nums1.length;
+        int n = nums2.length;
+        int halfTotalLen = (m + n) / 2;
+        int left = 0;
+        int right = m - 1;
+        // A median always exists in a non-empty array, so continue binary search until
+        // it’s found.
+        while (true) {
+            // Reminder: integer division rounds toward 0 in Java
+            // ex: -1 / 2 = 0
+            int L1Index = Math.floorDiv(left + right, 2);
+            int L2Index = halfTotalLen - (L1Index + 1) - 1;
+            // Set to -infinity or +infinity if out of bounds.
+            float L1 = L1Index < 0 ? Float.NEGATIVE_INFINITY : nums1[L1Index];
+            float R1 = L1Index >= m - 1 ? Float.POSITIVE_INFINITY : nums1[L1Index + 1];
+            float L2 = L2Index < 0 ? Float.NEGATIVE_INFINITY : nums2[L2Index];
+            float R2 = L2Index >= n - 1 ? Float.POSITIVE_INFINITY : nums2[L2Index + 1];
+            // If 'L1 > R2', then 'L1' is too far to the right. Narrow the search space
+            // toward the left.
+            if (L1 > R2) {
+                right = L1Index - 1;
+            }
+            // If 'L2 > R1', then 'L1' is too far to the left. Narrow the search space
+            // toward the right.
+            else if (L2 > R1) {
+                left = L1Index + 1;
+            }
+            // If both 'L1' and 'L2' are less than or equal to both 'R1' and 'R2', we 
+            // found the correct slice.
+            else {
+                if ((m + n) % 2 == 0) {
+                    return (Math.max(L1, L2) + Math.min(R1, R2)) / 2.0;
+                } else {
+                    return Math.min(R1, R2);
+                }
+            }
+        }
+    }
+}

java/Binary Search/FindTheTargetInARotatedSortedArray.java

@@ -0,0 +1,37 @@
+public class FindTheTargetInARotatedSortedArray {
+    public int findTheTargetInARotatedSortedArray(int[] nums, int target) {
+        if (nums == null || nums.length == 0) return -1;
+        int left = 0;
+        int right = nums.length - 1;
+        while (left < right) {
+            int mid = left + (right - left) / 2;
+            if (nums[mid] == target) {
+                return mid;
+            }
+            // If the left subarray [left : mid] is sorted, check if the 
+            // target falls in this range. If it does, search the left 
+            // subarray. Otherwise, search the right.
+            else if (nums[left] <= nums[mid]) {
+                if (nums[left] <= target && target < nums[mid]) {
+                    right = mid - 1;
+                } else {
+                    left = mid + 1;
+                }
+            }
+            // If the right subarray [mid : right] is sorted, check if the
+            // target falls in this range. If it does, search the right
+            // subarray. Otherwise, search the left.
+            else {
+                if (nums[mid] < target && target <= nums[right]) {
+                    left = mid + 1;
+                } else {
+                    right = mid - 1;
+                }
+            }
+            
+        }
+        // If the target is found in the array, return it's index. Otherwise,
+        // return -1.
+        return nums[left] == target ? left : -1;
+    }
+}

java/Binary Search/FirstAndLastOccurrencesOfANumber.java

@@ -0,0 +1,46 @@
+public class FirstAndLastOccurrencesOfANumber {
+    public int[] firstAndLastOccurrencesOfANumber(int[] nums, int target) {
+        int lowerBound = lowerBoundBinarySearch(nums, target);
+        int upperBound = upperBoundBinarySearch(nums, target);
+        return new int[]{lowerBound, upperBound};
+    }
+
+    private int lowerBoundBinarySearch(int[] nums, int target) {
+        if (nums == null || nums.length == 0) return -1;
+        int left = 0;
+        int right = nums.length - 1;
+        while (left < right) {
+            int mid = left + (right - left) / 2;
+            if (nums[mid] > target) {
+                right = mid - 1;
+            } else if (nums[mid] < target) {
+                left = mid + 1;
+            } else {
+                right = mid;
+            }
+        }
+        return nums[left] == target ? left : -1;
+    }
+
+    private int upperBoundBinarySearch(int[] nums, int target) {
+        if (nums == null || nums.length == 0) return -1;
+        int left = 0;
+        int right = nums.length - 1;
+        while (left < right) {
+            // In upper-bound binary search, bias the midpoint to the right.
+            int mid = left + (right - left) / 2 + 1;
+            if (nums[mid] > target) {
+                right = mid - 1;
+            } else if (nums[mid] < target) {
+                left = mid + 1;
+            } else {
+                left = mid;
+            }
+        }
+        // If the target doesn't exist in the array, then it's possible that
+        // 'left = mid + 1' places the left pointer outside the array when
+        // 'mid == n - 1'. So, we use the right pointer in the return 
+        // statement instead. 
+        return nums[right] == target ? right : -1;
+    }
+}

java/Binary Search/LocalMaximaInArray.java

@@ -0,0 +1,15 @@
+public class LocalMaximaInArray {
+    public int localMaximaInArray(int[] nums) {
+        int left = 0;
+        int right = nums.length - 1;
+        while (left < right) {
+            int mid = left + (right - left) / 2;
+            if (nums[mid] > nums[mid + 1]) {
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return left;
+    }
+}

java/Binary Search/MatrixSearch.java

@@ -0,0 +1,22 @@
+public class MatrixSearch {
+    public boolean matrixSearch(int[][] matrix, int target) {
+        int m = matrix.length;
+        int n = matrix[0].length;
+        int left = 0;
+        int right = m * n - 1;
+        // Perform binary search to find the target.
+        while (left <= right) {
+            int mid = left + (right - left) / 2;
+            int r = mid / n;
+            int c = mid % n;
+            if (matrix[r][c] == target) {
+                return true;
+            } else if (matrix[r][c] > target) {
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return false;
+    }
+}

java/Binary Search/WeightedRandomSelection.java

@@ -0,0 +1,29 @@
+public class WeightedRandomSelection {
+    int[] prefixSum;
+
+    public WeightedRandomSelection(int[] weights) {
+        this.prefixSum = new int[weights.length];
+        for (int i = 0; i < weights.length; i++) {
+            prefixSum[i] = i == 0 ? weights[i] : prefixSum[i-1] + weights[i];
+        }
+    }
+
+    private int select() {
+        // Pick a random target between 1 and the largest endpoint on the number 
+        // line.
+        int target = (int)(Math.random() * prefixSum[prefixSum.length - 1]) + 1;
+        int left = 0;
+        int right = prefixSum.length - 1;
+        // Perform lower-bound binary search to find which endpoint (i.e., prefix 
+        // sum value) corresponds to the target.
+        while (left < right) {
+            int mid = left + (right - left) / 2;
+            if (prefixSum[mid] < target) {
+                left = mid + 1;
+            } else {
+                right = mid;
+            }
+        }
+        return left;
+    }
+}