33. Search in Rotated Sorted Array

Suppose an array sorted in ascending order 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.

Subscribe to see which companies asked this question.

 

Solution:

Tips:

judge mid, left and right, be careful.

 

I found that there is something wrong with the code of leet code, such as the test cases below, and the result leet code give is wrong when the element over the half of a reverse order of the array, you can test it by yourself. My code works well.

 

Case 1:

 

Your input

[5,4,3,2,1]
4

Your answer

1

Expected answer

1

 

 

Case 2:

 

Your input

[5,4,3,2,1]
2

Your answer

3

Expected answer

-1

 

Case 3:

 

Your input

[5,4,3,2,1]
1

Your answer

4

Expected answer

-1

 

 

Java Code:

 

public class Solution {
    public int search(int[] nums, int target) {
        if (null == nums || nums.length < 1) {
            return -1;
        }
        int left = 0;
        int right = nums.length - 1;
        int mid = -1;

        while (left <= right ) {
            mid = left + (right - left) / 2;
            if (nums[mid] == target) {
                return mid;
            }

            if (target < nums[mid]) {
                if (target == nums[left]) {
                    return left;
                }
                if (target > nums[left] || nums[mid] < nums[right]) {
                    right = mid - 1;
                } else if (nums[mid] > nums[right]) {
                    left = mid + 1;
                } else {
                    break;
                }
            } else {
                if (target == nums[right]) {
                    return right;
                }
                if (target < nums[right] || nums[mid] > nums[left]) {
                    left = mid + 1;
                } else if (nums[mid] < nums[left]) {
                    right = mid - 1;
                } else {
                    break;
                }
            }
        }
        
        return -1;
    }
}

 

class Solution {
    public int search(int[] nums, int target) {
        int left = 0; 
        int right = nums.length - 1;
        
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (target == nums[mid]) {
                return mid;
            }
            
            // left < mid </> right
            if (nums[left] < nums[mid]) {
                if (target > nums[mid] || target < nums[left]) {
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
            } else if (nums[left] > nums[mid]) { // left > mid </> right
                if (target < nums[mid] || target > nums[right]) {
                    right = mid - 1;
                } else {
                    left = mid + 1;
                }
            } else { // left = mid
                left += 1;
            }
        }
        
        return -1;
    }
}