leetcode_40 Search in Rotated Sorted Array II

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?

算法：

The idea is the same as the previous one without duplicates

The only difference is that due to the existence of duplicates, we can have nums[left] == nums[mid] and in that case, the first half could be out of order (i.e. NOT in the ascending order, e.g. [3 1 2 3 3 3 3]) and we have to deal this case separately. In that case, it is guaranteed that nums[right] also equals to nums[mid], so what we can do is to check if nums[mid]== nums[left] == nums[right] before the original logic, and if so, we can move left and right both towards the middle by 1. and repeat.

与前面的一道题相比，大部分相同，唯一区别是会有重复元素，如果  nums[lo] == nums[mid] 前半部分将会乱序，需要先检查，如果乱序，lo++，hi--

class Solution {
public:
    bool search(vector<int>& nums, int target) {
        int lo = 0,hi = nums.size()-1;
        while(lo <= hi)
        {
            int mid = lo + (hi -lo)/2;
            if(target == nums[mid])
                return true;
            /* 3123333 */
            if(nums[lo] == nums[mid] && nums[lo] == nums[hi])
            {
                lo++ , hi--;
            }
            /*  4567012  t:3   45  t:4 */
            else if(nums[lo] <= nums[mid])
            {
                if(target >= nums[lo] && target < nums[mid] )
                {
                    hi = mid - 1;
                }
                else
                {
                    lo = mid + 1;
                }
            }
            else
            {
                if(target > nums[mid] && target <= nums[hi])
                {
                    lo = mid + 1;
                }
                else
                {
                    hi = mid - 1;
                }
            }
            
        }
        return false;
    }
};