add: firstAndLastOccurrencesOfANumber and findTheTargetInARotatedSortedArray

Author: Jer3myYu

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) / 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) / 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) / 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;
+    }
+}