Completed Binary-Search-1

Rotated_Sorted_Array.java

@@ -0,0 +1,36 @@
+// Time Complexity :O(log n)
+// Space Complexity :O(1)
+// Did this code successfully run on Leetcode :yes
+// Any problem you faced while coding this :no
+
+
+//Check for target based on which side of the array is sorted. 
+
+class Solution {
+    public int search(int[] nums, int target) {
+        int low, mid, high;
+        low = 0;
+        high = nums.length - 1;
+
+        while (low <= high) {
+            mid = low + (high - low) / 2;
+            if (nums[mid] == target) { // found target in mid
+                return mid;
+            } else if ( nums[low] <= nums[mid]) { //left side is sorted
+                if (nums[low] <= target && target < nums[mid]) {
+                    high = mid - 1;//target is in left side
+                } else {
+                    low = mid + 1;//target is in right side
+                }
+            } else {//right side is sorted
+                if (nums[mid] < target && target <= nums[high]) {
+                    low = mid + 1;//target is in right side
+                } else {
+                    high = mid - 1;//target is in left side
+                }
+            }
+
+        }
+        return -1;//not found
+    }
+}

Search_2D_Matrix.java

@@ -0,0 +1,35 @@
+// Time Complexity :O(log mn)
+// Space Complexity :O(1)
+// Did this code successfully run on Leetcode :yes
+// Any problem you faced while coding this :no
+
+
+// Treat the matrix as flattened array and do binary search. 
+// Corresponding mapping: row = mid/n, column = mid%n 
+
+class Solution {
+    public boolean searchMatrix(int[][] matrix, int target) {
+        int m = matrix.length;
+        int n=matrix[0].length;
+        int low,mid,high;
+        low=0;
+        high = m*n-1;//last element
+
+        while(low<=high){
+            mid=low+(high-low)/2;
+            int row = mid/n;
+            int column = mid%n;
+            if(matrix[row][column] == target){
+                return true;//target found
+            }
+            else if(matrix[row][column] > target){
+                high = mid - 1;//search in left side
+            }
+            else{
+                low = mid + 1;//search in right side
+            }
+        }
+        return false;//not found
+
+    }
+}

Sorted_Array_Of_Unknown_Size.java

@@ -0,0 +1,36 @@
+// Time Complexity :O(log n)
+// Space Complexity :O(1)
+// Did this code successfully run on Leetcode :no (premium question) 
+// Any problem you faced while coding this :no
+
+
+// Increment low and high until reaching target range. Then do binary search in that range. 
+
+class Solution {
+
+    public int search(ArrayReader reader, int target) {
+        int low, mid, high;
+        low = 0;
+        high = 1;
+
+        while(reader.get(high) < target){ //increment low and high until we reach the range of target by doubling high
+            low = high ;
+            high = 2*high;
+        }
+
+        while(low <= high){ 
+            mid = low + (high - low)/2;
+            if(reader.get(mid) == target) { //found target in mid
+                return mid;
+            }
+            if(reader.get(mid) > target){ //search in left side
+                high = mid - 1;
+            }
+            else{//search in right side
+                low = mid + 1;
+            }
+        }
+
+        return -1;//not found
+    }
+}