leetcode-33-Search in Rotated Sorted Array 查找

问题

题目：[Search in Rotated Sorted Array]

思路

这个题目整体的思路并不难，只是有许多细节需要注意。
首先，题目是升序序列。rotated之后，每个子序列都是升序列（这话没有错）。且第一个序列是元素值较大的序列，第二个是元素值较小的序列。
所以，大体的思路如下：

• 找到序列的边界，即小序列的起点pivot。
• 判断key是在大序列还是小序列中进行查找
• 在相应序列中进行二分查找

当然，有如下需要注意的点。
首先，寻找pivot的时候，需要分情况讨论.

$$arr[i-1] < arr[i] && arr[i] > arr[i+1]$$
$$arr[i-1] > arr[i] && arr[i] < arr[i+1]$$
这两种情形，pivot不一样。前者是i+1，后者是i。

其次，当只有两个元素的时候，一旦发生rotated。eg：[1,3]->[3,1]
这种情形看起来是没有rotated，因为只存在单一的序列，升序或者降序。
这时,pivot = 0。那么，在后续处理的时候，需要判断。如果是一个元素，那么采用升序的二分查找，多个的时候需要判断升序还是降序，采用对应的查找算法。

最后，在第二个子序列查找的时候，注意是相对位置即可。输入参数以及返回值的时候都需要判断。

代码(c实现)

// c version
int search(int* nums, int numsSize, int target) {

    if( NULL == nums || numsSize <= 0 )
        return -1;

    for( int i = 0; i < numsSize; ++i )
    {
        if( nums[i] == target )
            return i;
    }
    return -1;
}

代码1(c实现)

// c version
int find_pivot( int* arr, int n ) // 返回第二个序列起点
{
    if( NULL == arr || n <= 0 )
        return -1;

    for( int i = 1; i < n - 1; ++i ) 
    {
        if (arr[i-1] < arr[i] && arr[i] > arr[i+1])
                return i + 1;
        else if (arr[i-1] > arr[i] && arr[i] < arr[i+1])  
            return i;
    }
    return 0; // 不存在rotated的情形
}

int bi_search1( int* arr, int n, int key )
{
    if( NULL == arr || n <= 0 )
        return -1;
    else
    {
        int low = 0, high = n-1;
        int mid = 0;
        while( low <= high )
        {
            int mid = (low + high)/2;
            if( key == arr[mid] )
                return mid;
            else if( key < arr[mid] )
                high = mid - 1;
            else
                low = mid + 1;
        }
        return -1;
    }
}
int bi_search2( int* arr, int n, int key )
{
    if( NULL == arr || n <= 0 )
        return -1;
    else
    {
        int low = 0, high = n-1;
        int mid = 0;
        while( low <= high )
        {
            int mid = (low + high)/2;
            if( key == arr[mid] )
                return mid;
            else if( key < arr[mid] )
                low = mid + 1;
            else
                high = mid - 1;
        }
        return -1;
    }
}

int search(int* nums, int numsSize, int target) {

    int pivot = find_pivot( nums, numsSize );
    //printf( "pivot = %d\n", pivot );
    if( -1 == pivot )
        return -1;
    else if( !pivot )
    {
        if( numsSize > 1 )
        {
            if( nums[0] < nums[1] )
                return bi_search1( nums, numsSize, target ) ; // 升序
            else
                return bi_search2( nums, numsSize, target );  // 降序
        }
        else
            return bi_search1( nums, numsSize, target ) ; // 升序
    }
    else
    {
        if( target >= nums[0] ) // 第一个序列
        {
            return bi_search1( nums, pivot + 1, target );
        }
        else // 第二个序列
        {
            int ret = bi_search1( nums + pivot , numsSize - pivot , target );
            if( -1 == ret )
                return -1;
            else
                return pivot + ret;         
        }
    }   
}

代码(c++实现)

// c++ version
class Solution {
public:
    int search( std::vector<int>& nums, int target) {

        int sz = nums.size();
        if( !sz )
            return -1;

        int pivot = find_pivot( nums );
        std::cout << "pivot = "<< pivot << std::endl;
        if( -1 == pivot )
            return -1;
        else if( !pivot )
        {
            if( sz > 1 )
            {
                if( nums[0] < nums[1] ) // 升序
                    return bi_search1( nums, target );
                else                    // 降序
                    return bi_search2( nums, target );
            }
            else
                return bi_search1( nums, target );
        }
        else
        {
            if( target >= nums[0] ) // 大序列查找
            {

                return bi_search1( std::vector<int>( nums.begin(), nums.begin() + pivot ), target );
            }
            else // 小序列查找
            {
                int ret =  bi_search1( std::vector<int>( nums.begin() + pivot, nums.end() ), target );
                if( -1 == ret )
                    return -1;
                else
                    return pivot+ret;

            }
        }

    }

private:

    int find_pivot( const std::vector<int>& nums  )
    {
        int sz = nums.size();
        if(!sz)
            return -1;
        else if(1 == sz)
            return 0; // 单一序列

        for( int i = 1; i < sz - 1; ++i )
        {
            if( nums[i-1] < nums[i] && nums[i] > nums[i+1] )
                return i + 1;
            else if( nums[i-1] > nums[i] && nums[i] < nums[i+1] )
                return i;
        }


        return 0; // 单一序列
    }

    int bi_search1( const std::vector<int>& nums, int target )
    {
        int sz = nums.size();
        if( !sz )
            return -1;
        int low = 0;
        int high = sz - 1;
        while( low <= high )
        {
            int mid = (low + high)/2;
            if( target == nums[mid] )
                return mid;
            else if ( target < nums[mid] )
                high = mid - 1;
            else
                low = mid + 1;
        }
        return -1;
    }
    int bi_search2( const std::vector<int>& nums, int target )
    {
        int sz = nums.size();
        if( !sz )
            return -1;
        int low = 0;
        int high = sz - 1;
        while( low <= high )
        {
            int mid = (low + high)/2;
            if( target == nums[mid] )
                return mid;
            else if ( target < nums[mid] )
                low = mid + 1;
            else
                high = mid - 1;
        }
        return -1;
    }


};

再刷

思路：本质还是二分查找。但是，问题是不知道原来的数组在哪旋转了。可以发现一点是：旋转后的两个子序列都是有序的。

• nums[mid] < nums[high]，那么[mid, high]可以保证是有序的，[low,mid]，可能是有序的，也可能是rotate数组。此时，对于一定是有序的部分[mid, high]，我们可以判断target是否在这个部分，如果在，其实二分就搞定了。如果不在，左边是和当前一样的数组，再次进行查找即可。
• nums[low] < nums[mid]一样的道理。一定要找到完全有序的区间，查找。

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

            if( nums[mid] < nums[high] ) { // [mid,high] is sorted
                if( nums[mid] < target && target <= nums[high] ) low = mid+1;
                else high = mid-1;
            }
            else{ // [low, mid] is sorted
                if( nums[low] <= target && target < nums[mid] ) high = mid-1;
                else low = mid + 1;
            }
        }
        return -1;
    }
};