Adding the solutions

SearchA2DMatrix.java

@@ -0,0 +1,58 @@
+// TimeComplexity: O(logmn)
+// SpaceComplexity: O(1)
+class Solution {
+    public boolean searchMatrix(int[][] matrix, int target) {
+        int m = matrix.length;
+        int n = matrix[0].length;
+
+        int low = 0;
+        int high = m*n -1;
+        int mid;
+
+        while (low <= high) {
+            mid = low + (high-low)/2;
+
+            if (target == matrix[mid/n][mid%n]) {
+                return true;
+            }
+
+            if (target < matrix[mid/n][mid%n]) {
+                high = mid -1;
+            } else {
+                low = mid+1;
+            }
+        }
+        return false;
+    }
+}
+
+// TimeComplexity: O(m+logn)
+// SpaceComplexity: O(1)
+
+class Solution {
+    public boolean searchMatrix(int[][] matrix, int target) {
+        int m = matrix.length;
+        int n = matrix[0].length;
+        if(target<matrix[0][0] || target > matrix[m-1][n-1]) return false;
+        int row =-1;
+        for(int i =0; i<m; i++) {
+            if(target<=matrix[i][n-1]) {
+                row = i;
+                break;
+            }
+        }
+        int low = 0;
+        int high = n-1;
+        while(low<=high) {
+            int mid = low+ (high-low)/2;
+            if(matrix[row][mid] == target) return true;
+            if(matrix[row][mid]<target) {
+                low=mid+1;
+            } else {
+                high = mid-1;
+            }
+        }
+        return false;
+
+    }
+}

SearchInInfiniteSortedArray.java

@@ -0,0 +1,57 @@
+// TimeComplexity: O(logn)
+// SpaceComplexity: O(1)
+
+class Solution {
+public:
+    int search(const ArrayReader& reader, int target) {
+        int low =0;
+        int high =10001;
+
+        while(low<=high) {
+            int mid = low+ (high-low)/2;
+            if(reader.get(mid) == target) {
+                return mid;
+            }
+            if(reader.get(mid)<target) {
+                low = mid+1;
+            } else {
+                high = mid-1;
+            }
+        }
+        return -1;
+
+
+    }
+};
+
+
+
+ // Time Complexity: O(logn)
+ // SpaceComplexity: O(1)
+
+class Solution {
+public:
+    int search(const ArrayReader& reader, int target) {
+        int low =0;
+        int high =1;
+        while(reader.get(high) < target) {
+            low = high;
+            high = high*2;
+        }
+
+        while(low<=high) {
+            int mid = low+ (high-low)/2;
+            if(reader.get(mid) == target) {
+                return mid;
+            }
+            if(reader.get(mid)<target) {
+                low = mid+1;
+            } else {
+                high = mid-1;
+            }
+        }
+        return -1;
+
+
+    }
+};

SearchInRotatedSortedArray.java

@@ -0,0 +1,30 @@
+// TimeComplexity: O(logn)
+// SpaceComplexity: O(1)
+
+class Solution {
+    public int search(int[] nums, int target) {
+        int n = nums.length;
+        int low = 0;
+        int high = n-1;
+        while(low<=high) {
+            int mid = low + (high - low)/2;
+            if (nums[mid] == target) return mid;
+            if(nums[low]<= nums[mid]) {
+                // left sorted
+                if(nums[low] <= target && target < nums[mid]) {
+                    high = mid-1;
+                } else {
+                    low = mid+1;
+                }
+            } else {
+                // right sorted
+                if(nums[mid] < target && target<= nums[high]) {
+                    low = mid+1;
+                } else {
+                    high = mid-1;
+                }
+            } 
+        }
+        return -1;
+    }
+}