LeetCode Solutions : Search in Rotated Sorted Array

Suppose a sorted array is rotated at some pivot unknown to you beforehand.

(i.e., 0 1 2 4 5 6 7 might become 4 5 6 7 0 1 2).

You are given a target value to search. If found in the array return its index, otherwise return -1.

You may assume no duplicate exists in the array.

Java Solutions:

public class Solution {
    public int search(int[] A, int target) {
        if(A.length==0)
			return -1;
		int low=0;
		int high=A.length-1;
		while(low<=high){
			int mid=low+(high-low)/2;
			if(A[mid]==target)
				return mid;
			if(A[low]<=A[mid]){// the elements from low to mid is strictly increasing order
				if(A[low]<=target&&target<A[mid])
					high=mid-1;
				else
					low=mid+1;
			}else{// the elements from mid to high is strictly increasing order
				if(A[mid]<target&&target<=A[high])
					low=mid+1;
				else
					high=mid-1;
			}
		}
		return -1;
    }
}

Challenge yourself with finding the start position of strictly increasing sub-array :

Some Test Cases:

{ 1 }
return 0

{ 1, 2 }
return 0

{ 2, 1 }
return 1

{ 1, 2, 3 }
return 0

{ 3, 1, 2 }
return 1

{ 2, 3, 1 }
return 2

{ 1, 2, 3, 4, 5 }
return 0

{ 2, 3, 4, 5, 1 }
return 4

{ 3, 4, 5, 1, 2 }
return 3

{ 4, 5, 1, 2, 3 }
return 2

{ 5, 1, 2, 3, 4 }
return 1

{ 1, 2, 3, 4, 5, 6 }
return 0

{ 2, 3, 4, 5, 6, 1 }
return 5

{ 3, 4, 5, 6, 1, 2 }
return 4

{ 4, 5, 6, 1, 2, 3 }
return 3

{ 5, 6, 1, 2, 3, 4 }
return 2

{ 6, 1, 2, 3, 4, 5 }
return 1

{ 6, 8, 1, 2, 4, 5 }
return 2

public int findStartIndex(int[] A){
	int low=0;
	int high=A.length-1;
	while(A[low]>A[high]){
		int mid=low+(high-low)/2;
		if(A[mid]<A[high])
			low=mid+1;
		else
			high=mid;
	}
	return low;
}