[leetcode]33. Search in Rotated Sorted Array

题目链接：https://leetcode.com/problems/search-in-rotated-sorted-array/#/description

 

 

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.

思路：

My solutions use binary search guided by the following thoughts:

Remember the array is sorted, except it might drop at one point.

• If nums[0] <= nums[i], then nums[0..i] is sorted (in case of "==" it's just one element, and in case of "<" there must be a drop elsewhere). So we should keep searching in nums[0..i] if the target lies in this sorted range, i.e., if nums[0] <= target <= nums[i].

• If nums[i] < nums[0], then nums[0..i] contains a drop, and thus nums[i+1..end] is sorted and lies strictly between nums[i] and nums[0]. So we should keep searching in nums[0..i] if the target doesn't lie strictly between them, i.e., if target <= nums[i] < nums[0] or nums[i] < nums[0] <= target

Those three cases look cyclic:

    nums[0] <= target <= nums[i]
               target <= nums[i] < nums[0]
                         nums[i] < nums[0] <= target

So I have the three checks (nums[0] <= target), (target <= nums[i]) and (nums[i] < nums[0]), and I want to know whether exactly two of them are true. They can't all be true or all be false (check it), so I just need to distinguish between "two true" and "one true". Parity is enough for that, so instead of adding them I xor them, which is a bit shorter and particularly helpful in Java and Ruby, because those don't let me add booleans but do let me xor them.

(Actually while developing this I thought of permutations of nums[0], target and nums[i] and the permutation parity and saw those three checks as representing inversions, but I had trouble putting that into words and now find the above explanation much better. But it helped me get there, so I wanted to mention it here.)

 

最终版

class Solution {
public:
    int search(vector<int>& nums, int target) {
        if(nums.empty())
            return -1;
        int left=0,right=nums.size()-1;
        while(left<right)
        {
            if(nums[left]==target)
                return left;
            else if(nums[right]==target)
                return right;
            int mid=left+(right-left)/2;
            if(nums[mid]==target)
                return mid;

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

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

};

 

方法一：

class Solution {
public:
    /**
     * @param A: an integer rotated sorted array
     * @param target: an integer to be searched
     * @return: an integer
     */
    int search(vector<int> &A, int target) {
        // write your code here
        
        if(A.empty()) return -1;
        
        int l=0,r=A.size()-1,mid=0;
        while(l<=r)
        {
            mid=l+(r-l)/2;
            if(A[l]==target)
            {
                return l;
            }
            else if(A[r]==target)
            {
                return r;
            }
            else if(A[mid]==target)
            {
                return mid;
            }
            else if(A[A.size()-1]>A[0] && A[mid]>target)
            {
                r=mid-1;
            }
            else if(A[A.size()-1]>A[0] && A[mid]<target)
            {
                l=mid+1;
            }
            else if(A[mid]>=A[0] && A[mid]>target && target<=A[A.size()-1])
            {
                l=mid+1;
            }
            else if(A[mid]>=A[0] && A[mid]>target && target>A[A.size()-1])
            {
                r=mid-1;
            }
            else if(A[mid]>=A[0] && A[mid]<target && target>A[A.size()-1])
            {
                l=mid+1;
            }
            else if(A[mid]<A[0] && A[mid]<target && target>A[0])
            {
                r=mid-1;
            }
            else if(A[mid]<A[0] && A[mid]<target && target<A[0])
            {
                l=mid+1;
            }
            else if(A[mid]<A[0] && A[mid]>target && target<A[0])
            {
                r=mid-1;
            }
        }
        return -1;
    }
};

 

 

 

 

 

 

方法二：

 

 

class Solution {
public:
    int search(vector<int>& nums, int target) {
        if(nums.empty())
            return -1;
        int left=0,right=nums.size()-1;
        while(left<right)
        {
            int mid=left+(right-left)/2;
            if(nums[left]==target)
                return left;
            else if(nums[right]==target)
                return right;
            else if(nums[mid]==target)
                return mid;
            else if(nums[0]==target)
                return 0;
            else if(nums[0]<target && target<nums[mid] && nums[0]<=nums[mid])
                right=mid-1;
            //else if(nums[0]<target && target<nums[mid] && nums[0]>nums[mid]) //不存在
            //    left=mid+1;
            else if(nums[0]<target && target>nums[mid] && nums[0]<=nums[mid])
                left=mid+1;
            else if(nums[0]<=target && target>nums[mid] && nums[0]>nums[mid])
                right=mid-1;
            else if(nums[0]>target && target<nums[mid] && nums[0]<=nums[mid])
                left=mid+1;
            else if(nums[0]>target && target<nums[mid] && nums[0]>nums[mid])
                right=mid-1;
            //else if(nums[0]>target && target>nums[mid] && nums[0]<nums[mid]) //不存在
            //    right=mid-1;
            else if(nums[0]>target && target>nums[mid] && nums[0]>nums[mid])
                left=mid+1;
 
        }
        return target==nums[left]?left:-1;
    }
};

 

 

 

 

 

方法三：（方法一简化版）

 

class Solution{
public:
    int search(vector<int>& nums, int target) {
        if(nums.empty())
            return -1;
        int low = 0, high = int(nums.size()) - 1;
        while (low < high) {
            int mid =low+(high-low)/2;
            if(target==nums[low])
                return low;
            else if(target==nums[mid])
                return mid;
            else if(target==nums[high])
                return high;
            else if ((nums[0] > target) ^ (nums[0] > nums[mid]) ^ (target > nums[mid]))  
                low = mid + 1;
            else
                high=mid;    
            
        }
        return target==nums[low]?low:-1;

    }
};

 

 

 

 

 

 

 

class Solution{
public:
    int search(vector<int>& nums, int target) {
        int lo = 0, hi = int(nums.size()) - 1;
        while (lo < hi) {
            int mid = lo+(hi-lo)/2;
            if ((nums[0] > target) ^ (nums[0] > nums[mid]) ^ (target > nums[mid]))
                lo = mid + 1;
            else
                hi = mid;
        }
        return lo == hi && nums[lo] == target ? lo : -1;
    }
};

 

方法四：

 

 

class Solution {
public:
    int search(vector<int>& nums, int target) {
        if(nums.empty())
            return -1;
        int left=0,right=nums.size()-1;
        while(left<right)
        {
            if(nums[left]==target)
                return left;
            else if(nums[right]==target)
                return right;
            int mid=left+(right-left)/2;
            if(nums[mid]==target)
                return mid;
            else if(nums[mid]>target)
            {
                if(nums[mid]>=nums[left] && nums[left]>target)
                    left=mid+1;
                else if(nums[mid]>=nums[left] && nums[left]<target)
                    right=mid-1;
                else if(nums[mid]<nums[left] && nums[left]>target)
                    right=mid-1;
                //else if(nums[mid]<nums[left] && nums[left]<target) // bu cun zai

            }
            else if(nums[mid]<target)
            {
                //if(nums[mid]>=nums[left] && nums[left]>=target) // bu cun zai
                if(nums[mid]>=nums[left] && nums[left]<target)
                    left=mid+1;
                else if(nums[mid]<nums[left] && nums[left]>target)
                    left=mid+1;
                else if(nums[mid]<nums[left] && nums[left]<target)
                    right=mid-1;


            }
        }
        return target==nums[left]?left:-1;
    }
};