Binary-Search-1 completed

2DMatrixSearch.java

@@ -0,0 +1,30 @@
+/* Solved this using imaginary flattened 1D array
+* Time complexity is O(LogN)
+*/
+
+class Solution {
+    public boolean searchMatrix(int[][] matrix, int target) {
+
+         int m = matrix.length;
+         if (m == 0) return false;
+         int n = matrix[0].length;
+         int low = 0;
+         int high = m * n - 1;
+int mid;
+int elemnt;
+         while(low <= high){
+           mid = (low + high) / 2;
+           elemnt = matrix[mid/n][mid%n];
+
+        if(target == elemnt) return true;
+        else{
+            if(target < elemnt) high = mid - 1;
+            else low = mid + 1;
+        }
+
+         }
+
+
+return false;
+    }
+}

InfiniteSortedArray.java

@@ -0,0 +1,30 @@
+/**
+ * Solving using binary search, first trying to find the high point in the array
+ * Then runing Binary search in the remaining portion.
+ * Time complexity of O(LogN + LogM)
+ */
+
+class Solution {
+    public int search(ArrayReader reader, int target) {
+        int low = 0;
+        int high = 1;
+        if(reader.get(low) == target) return low;
+        while(reader.get(high) <= target){
+           low = high;
+           high *= 2;
+        }
+
+        while(low <= high){
+            int mid = (low + high) / 2;
+            if(reader.get(mid) == target) return mid;
+            if(reader.get(mid) > target){
+                high = mid - 1;
+                }
+            else{
+                low = mid + 1;
+            }
+        }
+
+        return -1;
+    }
+}

RotatedSortedArray.java

@@ -0,0 +1,35 @@
+/* SOlved using Binary search
+* Trying to find the sorted portion of tha array and then checking whether target
+* falls into that portion, otherwise removing the entire sorted portion
+* Time complexity will be O(LogN)
+*/
+
+class Solution {
+    public int search(int[] nums, int target) {
+        int low = 0, high = nums.length - 1;
+
+        while (low <= high) {
+            int mid = (low + high) / 2;
+
+            if (nums[mid] == target) {
+                return mid;
+            }
+
+            if (nums[low] <= nums[mid]) {
+                if (nums[low] <= target && target < nums[mid]) {
+                    high = mid - 1;
+                } else {
+                    low = mid + 1;
+                }
+            } else {
+                if (nums[mid] < target && target <= nums[high]) {
+                    low = mid + 1;
+                } else {
+                    high = mid - 1;
+                }
+            }
+        }
+
+        return -1;
+    }
+}