62 搜索旋转排序数组

原题网址：https://www.lintcode.com/problem/search-in-rotated-sorted-array/description

描述

假设有一个排序的按未知的旋转轴旋转的数组(比如，0 1 2 4 5 6 7 可能成为4 5 6 7 0 1 2)。给定一个目标值进行搜索，如果在数组中找到目标值返回数组中的索引位置，否则返回-1。

你可以假设数组中不存在重复的元素。

您在真实的面试中是否遇到过这个题？   是

样例

给出[4, 5, 1, 2, 3]和target=1，返回 2

给出[4, 5, 1, 2, 3]和target=0，返回 -1

挑战

O(logN) time

标签

二分法

数组

排序数组

 

思路：原始想法是找到旋转轴 i，找到后判断target在哪个部分，在哪个部分就对哪个部分使用二分法。时间复杂度是i+log（n-i）？

 

AC代码：

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
    int size=A.size();
    int index=-1;
    if (size==0)
    {
        return index;
    }
    int i=0;
    while(i<size-1&&A[i]<A[i+1])
    {
        i++;
    }
    if (i==size-1)//注意数组有可能未旋转，所以此处判断不可少;
    {
        index=binaryS(0,size-1,target,A);
    }
    else if (target<=A[size-1])//注意此处的逻辑是否则如果;
    {
        index=binaryS(i+1,size-1,target,A);
    }
    else
    {
        index=binaryS(0,i,target,A);
    }

    return index;
    }
    
    
    int binaryS(int left,int right,int target,vector<int> &A)
{
    int mid;
    while(left<=right)
    {
        mid=(left+right)/2;
        if (A[mid]==target)
        {
            return mid;
        }
        else if(A[mid]<target)
        {
            left=mid+1;
        }
        else
        {
            right=mid-1;
        }
    }

    return -1;
}
};

在网上搜索后，看到了更好的解法，参考： https://blog.csdn.net/ljlstart/article/details/48402741 

https://blog.csdn.net/guoziqing506/article/details/51139999   这个答案的文字描述很清晰，可以多看看。

https://www.jianshu.com/p/c9016d2bd003

 

二分查找法是在单调区间上确定 left、right 如何移动的过程，所以使用二分查找时应先确定区间，再在区间上查找。

 

题目中数组有两个递增区间，左侧部分任意值大于右侧部分最大值。可以先二分，判断 target 与 mid 关系，相等return mid，不相等继续寻找。

此时，可以判断 mid 处元素与 left 处元素大小，若 mid 大于 left ，说明 left~mid 这段是同一个递增区间。若 target 在此区间，二分查找， 即 righ = mid - 1。若 target 不在此区间，继续寻找 target 所在的递增区间，即 left = mid + 1；

若mid小于left，说明 mid 左侧不是单调区间， mid~right 这段是同一个递增区间。若 target 在此区间，二分查找，即 left = mid+1。若 target 不在此区间，继续寻找 target 所在的递增区间，即 righ = mid - 1 。

 

AC代码：

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
    int size=A.size();
    if (size==0)
    {
        return -1;
    }
    int left=0,right=size-1,mid;
    while(left<=right)
    {
        mid=(left+right)/2;
        if (A[mid]==target)
        {
            return mid;
        }
        if (A[mid]>A[left]) //left~mid在左侧递增区间上;
        {
            if (A[left]<=target&&target<A[mid])
            {
                right=mid-1;
            }
            else
            {
                left=mid+1;
            }
        }
        else //mid~right在右侧递增区间上;
        {
            if (target>A[mid]&&target<=A[right])
            {
                left=mid+1;
            }
            else
            {
                right=mid-1;
            }
        }
    }
    return -1;
        
    }
};