Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.

(i.e., [0,0,1,2,2,5,6] might become [2,5,6,0,0,1,2]).

You are given a target value to search. If found in the array return true, otherwise return false.

Example 1:

Input: nums = [2,5,6,0,0,1,2], target = 0
Output: true

Example 2:

Input: nums = [2,5,6,0,0,1,2], target = 3
Output: false

Follow up:

  • This is a follow up problem to Search in Rotated Sorted Array, where nums may contain duplicates.
  • Would this affect the run-time complexity? How and why?
  • class Solution {
        public boolean search(int[] nums, int target) {
            int n = nums.length;
            int l = 0, r = n - 1;
            while(l <= r){
                int mid = l + (r-l)/2;
                if(nums[mid] == target) return true;
                if(nums[mid] < nums[r]){//大条件,说明mid到r是升序
                    if(target > nums[mid] && target <= nums[r]) l = mid+1;//需要同时满足这两个条件
                    else r = mid-1;
                }
                else if(nums[mid] > nums[r]){
                    if(target < nums[mid] && target >= nums[l]) r = mid - 1;
                    else l = mid + 1;
                }
                else r--;//中间值等于最右值时,目标值既可以在左边又可以在右边,既然我们比较的是r,那就r--
            }
            return false;
        }
    }

    javascript:void(0)