*LeetCode 33. Search in Rotated Sorted Array 二分 值得一练

https://leetcode.com/problems/search-in-rotated-sorted-array/

先说一种相对简单的：首先二分找pivot 然后判断target可能在pivot之前还是之后，然后在可能的范围继续二分

class Solution {
public:
    int search(vector<int>& nums, int target) {
        if( nums.size() == 0 )return false;
        if( nums.size() == 1 ) {
            if(target == nums[0])
                return 0;
            return -1;
        }
        int pivot;
        //unsorted
        if( nums[ nums.size()-1 ] < nums[0] ) {
            //bisearch
            int left = 0, right = nums.size()-1;
            while( left <= right ) {
                int mid = (left+right) /2 ;
                if( nums[mid] >= nums[0] && nums[mid+1] < nums[0]  ){
                    pivot = mid+1;
                    break;
                } else {
                    if(nums[mid] < nums[0]) {
                        right = mid-1;
                    } else {
                        left = mid+1;
                    }
                }
            }
        } else {
            return biSearch(nums, 0, nums.size()-1, target);
        }
        //cout  << "pivot=" << pivot << endl;
        int ret ;
        if( target > nums[nums.size()-1] ) {
            return biSearch(nums, 0, pivot-1, target);
        } else {
            return biSearch(nums, pivot, nums.size()-1, target );
        }
    }

    int biSearch(vector<int> &nums, int st, int en, int tar) {
        int left = st, right = en;
        while( left<=right ) {
            int mid = (left+right)/2;
            if( nums[mid] == tar ) {
                //cout << "biSearch st=" << st << "  en=" << en << "  mid=" << mid << endl;
                return mid;
            }
            if( nums[mid] > tar ) {
                right = mid - 1;
            } else {
                left  = mid + 1;
            }
        }
        return -1;
    }
};

后来又想想，其实有更好的做法：

假设pivort就是两段数的分界，那么判断mid在哪段，target在哪段，以及mid和target的相对关系，然后二分，代码会更简洁一些：

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