LeetCode 33. 搜索旋转排序数组

解法一：先用二分法找到旋转数组中的最小值，然后分别在最小值的左边和右边进行二分查找，保持时间复杂度是O(logn)+O(logn),最终还是O(logn)

public class Solution {
    public int Search(int[] nums, int target) {
        if(nums==null || nums.Length<=0)
        {
            return -1;
        }

        int left = 0;
        int right = nums.Length - 1;

        int n = nums.Length - 1;

        int ans = left ;

        while (nums[left] >= nums[right])
        {
            int mid = ((right - left) >> 1) + left;

            if (right - left == 1)
            {
                ans = right;
                break;
            }

            if (nums[left] == nums[mid] && nums[right] == nums[mid] && nums[left] == nums[right])
            {
                int result = nums[left];
                for (int i = left + 1; i <= right; i++)
                {
                    if (nums[i] < result)
                    {
                        result = nums[i];
                        ans = i;
                    }
                }
                break;
            }

            if (nums[mid] >=nums[left])
            {
                left = mid;
            }
            else if (nums[mid] <= nums[right])
            {
                right = mid;
            }
        }

        if (nums[ans] == target)
        {
            return ans;
        }

        if (target < nums[n])
        {
            int l = ans, r = nums.Length - 1;

            while (l <= r)
            {
                int mid = ((r - l) >> 1) + l;

                if (nums[mid] > target)
                {
                    r = mid - 1;
                }
                else if (nums[mid] < target)
                {
                    l = mid + 1;
                }
                else
                {
                    return mid;
                }
            }
        }
        else if (target > nums[n])
        {
            int l = 0, r = ans - 1;

            while (l <= r)
            {
                int mid = ((r - l) >> 1) + l;

                if (nums[mid] > target)
                {
                    r = mid - 1;
                }
                else if (nums[mid] < target)
                {
                    l = mid + 1;
                }
                else
                {
                    return mid;
                }
            }
        }
        else
        {
            return n;
        }
        

        return -1;
    }
}

解法二：确定二分后的两个部分数组哪一个是有序的，在有序的部分里看目标是否在有序的部分中

public class Solution {
    public int Search(int[] nums, int target) {
        int left=0;
        int right=nums.Length-1;

        int n=right;

        int ans=0;

        if(n==0)
        {
            return nums[0]==target?0:-1;
        }

        while(left<=right)
        {
            int mid=((right-left)>>1)+left;

            if(nums[mid]==target)
            {
                return mid;
            }

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