completed Binary-Search-1

Problem-1.java

@@ -0,0 +1,35 @@
+// This solution uses binary search on the rows to dtermine whihc row our target might fall under
+// and after getting required row again binary search is applied on the  columns to check if the target is present in our 
+//row or not and returns true or false based on availability
+// Time Complexity: O(log m) for binary search rows and O(log n) for binary search on the row for target
+//  => O(log m + log n)=> O(log(m*n))
+
+class Solution {
+    public boolean searchMatrix(int[][] matrix, int target) {
+        int low = 0;
+        int high = matrix.length - 1;
+        int mid;
+        int columns = matrix[low].length - 1;
+        while (low != high) {
+            mid = low + (high - low) / 2;
+            if (target <= matrix[mid][columns]) {
+                high = mid;
+            } else
+                low = mid + 1;
+        }
+        int[] reqRow = matrix[high];
+        low = 0;
+        high = reqRow.length - 1;
+        while (low < high) {
+            mid = low + (high - low) / 2;
+            if (reqRow[mid] == target)
+                return true;
+            if (target < reqRow[mid]) {
+                high = mid;
+            } else
+                low = mid + 1;
+        }
+        boolean result = reqRow[high] == target ? true : false;
+        return result;
+    }
+}

Problem-2.java

@@ -0,0 +1,33 @@
+class SearchInRotatedSortedArray {
+    public int search(int[] nums, int target) {
+        int low = 0;
+        int high = nums.length - 1;
+        if (nums.length == 0)
+            return -1;
+
+        while (low < high) {
+            int midIndex = low + (high - low) / 2;
+            if (nums[midIndex] == target) {
+                return midIndex;
+            }
+            if (nums[low] <= nums[midIndex]) {
+                if ((target < nums[midIndex]) && (target >= nums[low])) {
+                    high = midIndex - 1;
+                } else {
+                    low = midIndex + 1;
+                }
+            } else if (nums[midIndex] < nums[high]) {
+
+                if ((target > nums[midIndex]) && (target <= nums[high])) {
+                    low = midIndex + 1;
+                } else {
+                    high = midIndex;
+                }
+
+            }
+
+        }
+        int index = (nums[high] == target) ? high : -1;
+        return index;
+    }
+}

Problem-3.java

@@ -0,0 +1,28 @@
+// This solution first calculates the upper bound and then applies binary search using the calculated upperbound
+//Time Complexity: O(log n + log n)=> O(2logN) => O(log n)
+
+class SearchInASortedArrayOfUnknownSize {
+    public int search(ArrayReader reader, int target) {
+        int upperBound = 1;
+        int low = 0;
+        int mid;
+        while (reader.get(upperBound) <= target) {
+            upperBound = upperBound * 2;
+        }
+
+        while (low < upperBound) {
+            mid = low + (upperBound - low) / 2;
+            int currMid = reader.get(mid);
+            if (currMid == target)
+                return mid;
+            if (target > currMid) {
+                low = mid + 1;
+            } else
+                upperBound = mid - 1;
+        }
+        if (reader.get(upperBound) == target)
+            return upperBound;
+        return -1;
+
+    }
+}