leetcode-81-Search in Rotated Sorted Array II 查找

问题

题目：[leetcode-81]

思路

跟[leetcode-33]相比，主要是重复元素的问题。举两个例子：
[3,5,5,5,1]和[5,1,1,1,3]，对于这种情况，算法的其余部分基本不变。

首先，是pivot的查找问题。
我做如下定义，如果一个序列存在一个升序对和一个降序对，那么我认为这个序列而存在一个逆序。那么现在的问题就转换为判断一个序列中是否存在一个逆序对。当前问题与之前问题的区别是，之前的问题逆序对是连续的。但是现在的逆序对是不连续的。

鉴于此，我的办法是分别设置一对升序和降序的标志。逆序的存在用这对标志进行判断。

其次，pivot的返回值对于这两种情形也稍有不同。
[3,5,5,5,1]的pivot=4,[5,1,1,1,3]的pivot = 2。对于后者pivot是第一个升序出现的地方。前者的pivot是第一个降序出现的地方。

再者，在执行search函数的时候，对于不存在逆序的序列进行查找的时候。需要判断第一个元素和最后一个元素来判断到底是升序，还是降序。

代码(c实现)

// c version
int find_pivot( int* arr, int n )
{
    if( NULL == arr || n <= 0 )
        return -1;

    bool asd = false; // 升序标志
    bool des = false; // 降序标志
    int first = 0;
    for( int i = 1; i < n - 1; ++i ) // arr[0] arr[n-1]一定不是pivot
    {
        if( arr[i - 1] < arr[i] )
            asd = true;
        if( arr[i - 1] > arr[i] )
        {   des = true; first = i;   }
        if( arr[i] > arr[i + 1] )
            des = true;
        if( arr[i] < arr[i+1] )
            asd = true;

        if( asd && des )
        {
            if( arr[i] < arr[i + 1] )
                return first;
            else if( arr[i] > arr[i+1] )
                return i + 1;
        }
    }
    return 0;
}

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

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

    int pivot = find_pivot( nums, numsSize );
    printf( "pivot = %d\n", pivot );
    if( -1 == pivot )
        return false;
    else if( !pivot )
    {
        if( numsSize > 1 )
        {
            if( nums[0] < nums[numsSize-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 // 小序列查找
        {
            return bi_search1( nums + pivot , numsSize - pivot , target );

        }
    }
}

思路1

我在用c++重写的时候，由于隔了一天。没有沿用之前的思路，就是按照思路去写的。其实大体思路差不多。

• 寻找pivot
• 判断在哪个序列中进行查找
• 在想应的序列查找即可

更新，find_pivot代码我做了一点更新，当然基本思路和c的方法一样。还是寻找代码中的逆序。需要设置两个标签。
还有，我注意到一个之前没有很好认识的性质。其实这个rotated array在pivot的前后，都是升序，只不过一个是大序列，一个是小序列。
由于返回的都是后面序列的第一个元素，所以我做了一点技巧。还是说例子。
[3,5,1],[5,1,3]，前者pivot = 2,后者pivot = 1。特点是，如果先降序后升序，那么pivot = i.如果是先降序后升序，那么pivot需要在之前保存。

int find_pivot( const std::vector<int>& nums )
{
    int sz = nums.size();
    if( !sz )
        return -1;

    bool asc = false;
    bool des = false;
    int first = 0;

    for( int i = 1; i < sz ; ++i )
    {
        if( nums[i-1] < nums[i] )
            asc = true;
        else if( nums[i-1] > nums[i] )
        {
            if( !asc )
                first = i;
            des = true;
        }

        if( asc && des )
        {
            if( first )
                return first;
            else
                return i;
        }

    }

    return 0; // 不存在逆序

}   

剩下的思路一样。

代码(c++实现)

class Solution {
public:
    bool search( std::vector<int>& nums, int target) {
        int sz = nums.size();
        if(!sz)
            return false;

        int pivot = find_pivot( nums );
        //std::cout << "pivot = " << pivot << std::endl;
        if( -1 == pivot )
            return false;
        else if( !pivot )
        {
            if( sz > 1 )
            {
                if( nums[0] > nums[sz-1] )
                    return bi_search2( nums, target );
                else
                    return bi_search1( 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
            {
                return bi_search1( std::vector<int>( nums.begin() + pivot, nums.end() ), target );
            }
        }



        return true;
    }
private:

    int find_pivot( const std::vector<int>& nums ) 
    {
        int sz = nums.size();
        if( !sz )
            return -1;

        bool asc = false;
        bool des = false;
        int first = 0;

        for( int i = 1; i < sz; ++i )
        {
            if( nums[i-1] < nums[i] )
                asc = true;
            else if( nums[i-1] > nums[i] )
            {
                if( !asc )
                    first = i;
                des = true;
            }

            if( asc && des )
            {
                if( first )
                    return first;
                else
                    return i;
            }

        }

        return 0; // 不存在逆序

    }

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

再刷

参考:[leetcode-81]
出现重复元素的问题在于，[3,1,1]以及[1,1,3,1]，此时3可以在左或者右，那么基本思路还是要比，直到存在a[mid]和a[right]的大小值不同时为止。

class Solution {
public:
    bool search(vector<int>& nums, int target) {
        int sz = nums.size();
        if(!sz) return false;

        int low = 0, high = sz-1;
        while(low <= high) {
            int mid = (low+high)/2;
            if( nums[mid] == target ) return true;

            if( nums[mid] < nums[high] ) {
                if( nums[mid] < target && target <= nums[high] ) low = mid+1;
                else high = mid-1;
            }
            else if( nums[mid] > nums[high] ) {
                if( nums[low] <= target && target < nums[mid] ) high = mid-1;
                else low = mid + 1;
            }
            else high--;
        }
        return false;
    }
};