done binarysearch1

InfiniteSortedArray.java

@@ -0,0 +1,27 @@
+// Time Complexity :o(logn logm)
+// Space Complexity :o(1) 
+// Did this code successfully run on Leetcode : it runs good in leat code
+// Any problem you faced while coding this : no
+ 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;
+    }
+}

Matrix2d.java

@@ -0,0 +1,41 @@
+// Time Complexity :o(logn)
+// Space Complexity :o(1) 
+// Did this code successfully run on Leetcode : it runs good in leat code
+// Any problem you faced while coding this : no
+class Solution {
+
+    public boolean searchMatrix(int[][] matrix, int target) {
+
+        if(matrix == null || matrix.length == 0) return false;
+
+        int m = matrix.length; int n = matrix[0].length;
+
+        int low = 0; int high = m*n-1;
+
+        while(low <= high){
+
+            int mid = low + (high- low)/2;
+
+            int r = mid/n; 
+
+            int c = mid%n;
+
+            if(matrix[r][c] == target) return true;
+
+            else if(matrix[r][c] > target){
+
+                high = mid - 1;
+
+            } else {
+
+                low = mid + 1;
+
+            }
+
+        }
+
+        return false;
+
+    }
+
+}

RotatedSortedArray.java

@@ -0,0 +1,39 @@
+// Time Complexity :o(logn)
+// Space Complexity :o(1) 
+// Did this code successfully run on Leetcode : it runs good in leat code
+// Any problem you faced while coding this : no
+
+class Solution {
+    public int search(int[] nums, int target) {
+        int n=nums.length;
+        if(n==0|| nums==null){
+            return -1;
+        }
+        {
+            int low= 0; int high= n-1;
+            while(low<high){
+                int mid= low+(high-low)/2;
+                if(nums[mid] == target){
+                     return mid;
+            } else if(nums[low]<=nums[mid]){
+                    //left sorted 
+
+                if(nums[low]<=target&&nums[mid]>target){
+                high=mid-1;
+            } else {
+                        low=mid+1;
+                    }
+                    }else {
+                    if(nums[mid]<target&&target<=nums[high]){
+                    low=mid+1;
+                }else{
+                    high=mid-1;
+                }
+            }
+
+        }
+        if(nums[low]==target)return low;
+        return -1;
+    }
+    }
+    }