From fb32d66af3b2e14e9ca9bffbbfcdc515c06f8498 Mon Sep 17 00:00:00 2001 From: Sanjoli Date: Sat, 6 Jun 2026 19:22:12 -0500 Subject: [PATCH 1/4] Done Binary Search 1 course --- Search.java | 34 ++++++++++++++++++++++++++++++++++ SearchMatrix.java | 30 ++++++++++++++++++++++++++++++ 2 files changed, 64 insertions(+) create mode 100644 Search.java create mode 100644 SearchMatrix.java diff --git a/Search.java b/Search.java new file mode 100644 index 00000000..5dc7e1ed --- /dev/null +++ b/Search.java @@ -0,0 +1,34 @@ +class Search { + + /* + // Time Complexity : O(2log n) = O(log n) + // Space Complexity : O(1) + To serach in an array of unknown size, we implement binary search but not starting with first and last + index of the array as it is unknown. We start with the first two indices of the array and check if the value at high index + is less than the target, then we increment the serch size of array by high * 2. We do this as long as we get a high index which is + less than the target value. Once we get the high index range, we do a regular binary search on the array to find index of the target element. + */ + + public int search(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; + } else if (reader.get(mid) > target) { + high = mid - 1; + } else { + low = mid + 1; + } + } + + return -1; + } +} \ No newline at end of file diff --git a/SearchMatrix.java b/SearchMatrix.java new file mode 100644 index 00000000..ee1e78d5 --- /dev/null +++ b/SearchMatrix.java @@ -0,0 +1,30 @@ +public class SearchMatrix { + + /* + // Time Complexity : O(log n + log m) + // Space Complexity : O(1) + To find a target element in a 2-D matrix which has elements sorted in ascending order, we are treating this 2D matrix as + an array which will make it possible to find element using binary search. To find the mid element in the matrix between + low and high indexes, we get the row index by dividing mid by column legth and column index by modulo operation with column length. + Then we compare if the value we are looking for is found return true. If its greater than mid element, we move the low pointer to mid + 1 index + else we move the high pointer to mid - 1. If we do not find the element, return false. + */ + + + public boolean searchMatrix(int[][] matrix, int target) { + int row = matrix.length;; + int col = matrix[0].length; + int low = 0; + int high = row * col - 1; + while (low <= high) { + int mid = low + (high - low)/2; + int r = mid/col; + int c = mid % col; + if (matrix[r][c] == target) return true; + else if (matrix[r][c] < target) low = mid + 1; + else high = mid - 1; + } + + return false; + } +} From 2c8232c3e68aeadb4037422efaa7658b06135e1a Mon Sep 17 00:00:00 2001 From: Sanjoli Date: Sat, 6 Jun 2026 19:26:05 -0500 Subject: [PATCH 2/4] Done Rotated sorted array course --- SearchRotatedSortedArray.java | 74 +++++++++++++++++++++++++++++++++++ 1 file changed, 74 insertions(+) create mode 100644 SearchRotatedSortedArray.java diff --git a/SearchRotatedSortedArray.java b/SearchRotatedSortedArray.java new file mode 100644 index 00000000..0bfa7ac9 --- /dev/null +++ b/SearchRotatedSortedArray.java @@ -0,0 +1,74 @@ +class SearchRotatedSortedArray { + public int search(int[] nums, int target) { + int index = checkIfArrayRotated(nums); + if (index > -1) { + nums = rotateArrayAtIndex(index, nums); + } + int found = binarySearch(nums, target); + if (found > -1 && index > -1) { + found = found + index + 1; + if (found >= nums.length) { + found %= nums.length; + } + } + return found; + } + + private int checkIfArrayRotated(int[] nums) { + int i = 0, j = nums.length - 1; + int index = -1; + while (j > i) { + if (nums[i] > nums[j]) { + j--; + index = j; + } + else { + break; + } + } + return index; + } + + private int[] rotateArrayAtIndex(int index, int[] arr) { + int[] rotatedArr = new int[arr.length]; + System.arraycopy(arr, index+1, rotatedArr, 0, (arr.length - 1 - index)); + System.arraycopy(arr, 0, rotatedArr, (arr.length - 1 - index), index+1); + return rotatedArr; + } + + private int binarySearch(int[] nums, int target) { + int found = -1; + int start = 0; + int end = nums.length - 1; + int mid = getMidIndex(start, end); + if ((start + end) % 2 != 0) { + mid = ((start + end) + 1) / 2; + } + else { + mid = nums.length / 2; + } + while (start <= end) { + if (nums[mid] > target) { + end = mid - 1; + } + else if (nums[mid] < target) { + start = mid + 1; + } + else { + found = mid; + break; + } + mid = getMidIndex(start, end); + } + return found; + } + + private int getMidIndex(int start, int end) { + if ((start + end) % 2 != 0) { + return ((start + end) + 1) / 2; + } + else { + return (start + end) / 2; + } + } +} \ No newline at end of file From 65889f9d796b0edf4f72cab60b751d7dc47dcb6e Mon Sep 17 00:00:00 2001 From: Sanjoli Date: Sat, 6 Jun 2026 19:31:21 -0500 Subject: [PATCH 3/4] revert --- SearchRotatedSortedArray.java | 71 ----------------------------------- 1 file changed, 71 deletions(-) diff --git a/SearchRotatedSortedArray.java b/SearchRotatedSortedArray.java index 0bfa7ac9..c5b20dd2 100644 --- a/SearchRotatedSortedArray.java +++ b/SearchRotatedSortedArray.java @@ -1,74 +1,3 @@ class SearchRotatedSortedArray { - public int search(int[] nums, int target) { - int index = checkIfArrayRotated(nums); - if (index > -1) { - nums = rotateArrayAtIndex(index, nums); - } - int found = binarySearch(nums, target); - if (found > -1 && index > -1) { - found = found + index + 1; - if (found >= nums.length) { - found %= nums.length; - } - } - return found; - } - private int checkIfArrayRotated(int[] nums) { - int i = 0, j = nums.length - 1; - int index = -1; - while (j > i) { - if (nums[i] > nums[j]) { - j--; - index = j; - } - else { - break; - } - } - return index; - } - - private int[] rotateArrayAtIndex(int index, int[] arr) { - int[] rotatedArr = new int[arr.length]; - System.arraycopy(arr, index+1, rotatedArr, 0, (arr.length - 1 - index)); - System.arraycopy(arr, 0, rotatedArr, (arr.length - 1 - index), index+1); - return rotatedArr; - } - - private int binarySearch(int[] nums, int target) { - int found = -1; - int start = 0; - int end = nums.length - 1; - int mid = getMidIndex(start, end); - if ((start + end) % 2 != 0) { - mid = ((start + end) + 1) / 2; - } - else { - mid = nums.length / 2; - } - while (start <= end) { - if (nums[mid] > target) { - end = mid - 1; - } - else if (nums[mid] < target) { - start = mid + 1; - } - else { - found = mid; - break; - } - mid = getMidIndex(start, end); - } - return found; - } - - private int getMidIndex(int start, int end) { - if ((start + end) % 2 != 0) { - return ((start + end) + 1) / 2; - } - else { - return (start + end) / 2; - } - } } \ No newline at end of file From 196846aa2868993fa943adb82d90b96fb6a7a1bb Mon Sep 17 00:00:00 2001 From: Sanjoli Date: Sat, 6 Jun 2026 22:11:44 -0500 Subject: [PATCH 4/4] fixed code --- SearchRotatedSortedArray.java | 37 ++++++++++++++++++++++++++++++++++- 1 file changed, 36 insertions(+), 1 deletion(-) diff --git a/SearchRotatedSortedArray.java b/SearchRotatedSortedArray.java index c5b20dd2..f88f7126 100644 --- a/SearchRotatedSortedArray.java +++ b/SearchRotatedSortedArray.java @@ -1,3 +1,38 @@ class SearchRotatedSortedArray { - + /* + Time complexity - O(log n) + Space complexity = O(1) + to search in a rotated sorted array using binary search, we need to determine in which + part of the array the target lies in. If mid element >= low element, it means the array + is in sorted order. Check if mid element > target and low element <= target, if so we + search in the left side lese we search in the right side of the array. When searching in + right side if mid element < target and high ele is >= target then search in the right side of mid + else search on the left side. If mid element equals target we return index. Else we return -1. + */ + public int search(int[] nums, int target) { + int low = 0; + int high = nums.length - 1; + + while (low <= high) { + int mid = low + (high - low)/2; + if (nums[mid] == target) { + return mid; + } + if (nums[mid] >= nums[low]) { + if (nums[mid] > target && nums[low] <= target) { + high = mid - 1; + } else { + low = mid + 1; + } + } else { + if (nums[mid] < target && nums[high] >= target) { + low = mid + 1; + } else { + high = mid - 1; + } + } + } + + return -1; + } } \ No newline at end of file