9.3

Question:

Given a sorted array of n integers that has been rotated an unknown number of times, give an O(log n) algorithm that finds an element in the array. You may assume that the array was originally sorted in increasing order.
EXAMPLE:
Input: find 5 in array (15 16 19 20 25 1 3 4 5 7 10 14)
Output: 8 (the index of 5 in the array)

This question is similar to Search in Rotated Sorted Array Leetcode I & II.

　　I:

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.

 

II: 

Follow up for "Search in Rotated Sorted Array":
What if duplicates are allowed?

Would this affect the run-time complexity? How and why?

Write a function to determine if a given target is in the array.

Solution: 

　　I: 

　　Use binary search. No matter how many times it is rotated, it's always true that one side is sorted.

　　if target > A[mid]

　　　　if A[mid] < A[high] (right side is sorted), 

　　　　　　if target > A[high] search in the left;

　　　　　　else search in the right;

　　　　else search in the right;

　　if target < A[mid] 

　　　　if A[mid] < A[high] (right side is sorted);

　　　　　　search in the left;

　　　　else  if target < A[low] search in the right;

　　　　　　　else search in the left;

　　else return mid;

　　　　if A[mid] < A[high] (right) 

public int search(int[] A, int target) {
　　if (A == null || A.length == 0) 
　　　　return -1;
　　int length = A.length;
　　int low = 0;
　　int high = length - 1;
　　while (low <= high) {
　　　　int mid = (high + low)/2;
　　　　if (target > A[mid]) {
　　　　　　// rightside is sorted
　　　　　　if (A[mid] < A[high]) {
　　　　　　　　if (target > A[high])
　　　　　　　　　　high = mid - 1;
　　　　　　　　else low = mid + 1;
　　　　　　}
　　　　　　// left side is sorted
　　　　　　else {
　　　　　　　　low = mid + 1;
　　　　　　}
　　　　}
　　　　else if (target < A[mid]) {
　　　　　　if (A[mid] < A[high]) 
　　　　　　　　high = mid - 1;
　　　　　　else {
　　　　　　　　if (target < A[low]) {
　　　　　　　　　　low = mid + 1;
　　　　　　　　}
　　　　　　　　else {
　　　　　　　　　　high = mid - 1;
　　　　　　　　}
　　　　　　}
　　　　}
　　　　else return mid;
　　}
　　return -1;
}