23 Median of Two Sorted Arrays

public double findMedianSortedArrays(int[] A, int[] B) {

int m = A.length;
int n = B.length;
if ((m + n) % 2 != 0) // odd
return (double) findKth(A, B, (m + n) / 2, 0, m - 1, 0, n - 1);
else { // even
return (findKth(A, B, (m + n) / 2, 0, m - 1, 0, n - 1) +
findKth(A, B, (m + n) / 2 - 1, 0, m - 1, 0, n - 1)) * 0.5;
}
}

public static int findKth(int A[], int B[], int k, int aStart, int aEnd, int
bStart, int bEnd) {

int aLen = aEnd - aStart + 1;

int bLen = bEnd - bStart + 1;

// Handle special cases

if (aLen == 0)
return B[bStart + k];
if (bLen == 0)
return A[aStart + k];
if (k == 0)
return A[aStart] < B[bStart] ? A[aStart] : B[bStart];

int aMid = aLen * k / (aLen + bLen); // a’s middle count

int bMid = k - aMid - 1; // b’s middle count

// make aMid and bMid to be array index

aMid = aMid + aStart;
bMid = bMid + bStart;

if (A[aMid] > B[bMid]) {

k = k - (bMid - bStart + 1);
aEnd = aMid;
bStart = bMid + 1;
} else {
k = k - (aMid - aStart + 1);
bEnd = bMid;
aStart = aMid + 1;
}
return findKth(A, B, k, aStart, aEnd, bStart, bEnd);
}
24 Search Insert Position
public int searchInsert(int[] nums, int target) {

int left = 0; int right = nums.length -1;

while(left <= right){

int mid = (left+right)/2;

if(nums[mid] == target){
return mid;
}

if(target < nums[mid]) { // Move Left

right = mid-1;
}
else {
left = mid+1; // Move Right
}
}
return left;
}

25_26 Find Minimum in Rotated Sorted

Array without Duplicates/ with Duplicates
public int findMin (int[] nums) {
if(nums==null || nums.length==0)
return -1;

int left=0;
int right=nums.length-1;

while(left <= right){

//handle duplicates .. cases like [3, 1, 3]
while(nums[left]==nums[right] && left != right){
left++;
}

if(nums[left] <= nums[right])

return nums[left];

int mid =(left + right)/2;

if(nums[mid] >= nums[left]){

left = mid + 1;
} else {
right = mid;
}
}
return -1;
}
24 Search Insert Position
public int searchInsert(int[] nums, int target) {
int left = 0; int right = nums.length -1;

while(left <= right){

int mid = (left+right)/2;

if(nums[mid] == target){
return mid;
}

if(target < nums[mid]) { // Move Left

right = mid-1;
}
else {
left = mid+1; // Move Right
}
}
return left;
}

25_26 Find Minimum in Rotated Sorted Array

public int findMin (int[] nums) {
if(nums==null || nums.length==0)
return -1;

int left=0;
int right=nums.length-1;

while(left <= right){

//handle duplicates .. cases like [3, 1, 3]

while(nums[left]==nums[right] && left != right){
left++;
}

if(nums[left] <= nums[right])

return nums[left];

int mid =(left + right)/2;

if(nums[mid] >= nums[left]){

left = mid + 1;
} else {
right = mid;
}
}
return -1;
}
28 Guess Number Higher or Lower
public int guessNumber(int n) {
int left = 0; int right = n;
while(left <= right) {
int mid = left+ ((right-left)/2);
int g = guess(mid);
if(g == 0) return mid;
else if(g == 1) {
left = mid+ 1 ;
}
else {
right = mid-1;
}
}
return -1;
}

29 First Bad Version

public int firstBadVersion(int n) {

int left = 1; int right = n;
while(left < right){
int mid = left + (right - left) / 2;
if(isBadVersion(mid)){
right = mid;
}
else {
left = mid+1;
}
}
return left;

}
30_31 Search in Rotated Sorted Array with/without Duplicates
public int search(int[] nums, int target) {
return recbinSearch(nums, 0, nums.length-1, target);
}

public int recbinSearch(int[] nums, int start, int end, int target ) {

int mid = (start+end)/2;

if(target == nums[mid])
return mid;
if(start > end)
return -1;

// if left normally sorted,

if(nums[start] < nums[mid]) {
// start -- target -- mid-1
if( nums[start] <= target && target < nums[mid]) {

return recbinSearch(nums, start, mid-1, target);

}
else {
return recbinSearch(nums, mid + 1, end, target);
}
}

// if right normally sorted,

else if ( nums[start] > nums[mid]) {
// mid+1 -- target -- end
if( nums[mid] < target && target <= nums[end]) {
return recbinSearch(nums, mid+1, end, target);
}
else {
return recbinSearch(nums, start, mid-1, target);
}
}

// repeated nums
else if (nums[start] == nums[mid]){ //left repeated
// left repeated right diff
if(nums[mid] != nums[end]) {
// search right
return recbinSearch(nums, mid+1, end, target);
}
else {
// search both sides
int result = recbinSearch(nums, start, mid-1, target);
if(result == -1)
return recbinSearch(nums, mid+1, end, target);
else
return result;
}
}
return -1;
}