【LeetCode】搜索旋转排序数组【两次二分】

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。

搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。

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

你的算法时间复杂度必须是 O(log n) 级别。

示例 1:

输入: nums = [4,5,6,7,0,1,2], target = 0
输出: 4

示例 2:

输入: nums = [4,5,6,7,0,1,2], target = 3
输出: -1

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-in-rotated-sorted-array

分析：时间复杂度要求是O（log N）,原数组又是通过有序的数组变换得来的，所以我们可以联想到二分

先二分得到分割点k，分割点具有这样的特征:nums[k]>=nums[k+1]

找到了分割点k，我们可以得到两个区间:[0，k】，【k+1,n-1]

通过比较两个区间端点和target的大小关系，我们可以确定target位于两个区间中的哪一个

区间中的数肯定是有序的，这样我们可以在区间中继续通过二分来寻找target

总结：

两个二分，第一次寻找分割点，第二次寻找target

时间复杂度:O（log N）

空间复杂度:O（1）

 

class Solution {
public:
int search(vector<int>& v, int t)
{
    int k=-1;
    int n=v.size();
    if(n==0)
        return -1;
    if(n==1)
    {
        if(v[0]==t)
            return 0;
        else
            return -1;
    }
   
    int l,h;
    l=0;
    h=n-1;
    if(v[l]<v[h])//不存在分割点
    {
        k=-1;
    }
    else
    {
        while(l<=h)//寻找分割点
        {
            int mid=(l+h)/2;
            if(mid+1<=n-1&&v[mid]>v[mid+1])
            {
                k=mid;
                break;
            }
            else
            {
                if(v[mid]<v[l])
                    h=mid-1;
                else
                    l=mid+1;
            }
        }
    }
    //通过分割点确定target所属区间
    if(k==-1)
    {
        if(t>v[n-1])
            return -1;
        if(t<v[0])
            return -1;
        l=0;
        h=n-1;
    }
    if(t>v[n-1])
    {
        l=0;
        h=k;
    }
    else if(t<v[0])
    {
        l=k+1;
        h=n-1;
    }
    while(l<=h)//在区间中二分寻找target
    {
        int mid=(l+h)/2;
        if(v[mid]>t)
        {
            h=mid-1;
        }
        else if(v[mid]<t)
        {
            l=mid+1;
        }
        else if(v[mid]==t)
        {
            return mid;
        }
    }
    return -1;
}
};
func search(nums []int, target int) int {
	// 4,5,6,7,0,1,2
	l,h:=0,len(nums)-1

	var k int
	// 不存在分界点
	if nums[l]<=nums[h]{
		k=-1
	}else {
		//  第一步：先寻找分界点k nums[k]>nums[k+1]
		for l<=h{
			mid:=(l+h)/2
			if mid+1<len(nums)&&nums[mid]>nums[mid+1]{
				k=mid
				break
			}else {
				if nums[mid]<nums[l]{
					h=mid-1
				}else {
					l=mid+1
				}
			}
		}
	}

	// 第二步：通过k确定target所属区间 l和h
	if k==-1{
		// 不存在target的特殊情况，排除掉
		if target>nums[len(nums)-1]{
			return -1
		}
		if target<nums[0]{
			return -1
		}
		if target==nums[0]{
			return 0
		}
		l=0
		h=len(nums)-1
	}

	if target>nums[len(nums)-1]{
		l=0
		h=k
	}
	if target<nums[0]{
		l=k+1
		h=len(nums)-1
	}

	// 第三步：针对此区间，二分查找target

	for l<=h{
		mid:=(l+h)/2
		if nums[mid]==target{
			return mid
		}else if nums[mid]>target{
			h=mid-1
		}else if nums[mid]<target{
			l=mid+1
		}
	}

	return -1
}

　　

 

posted @ 2019-08-19 19:43  西*风  阅读(150)  评论(0)  编辑  收藏  举报