【LeetCode】Search in Rotated Sorted Array

Suppose a sorted array is rotated at some pivot unknown to you beforehand.

(i.e., 0 1 2 4 5 6 7 might become 4 5 6 7 0 1 2).

You are given a target value to search. If found in the array return its index, otherwise return -1.

You may assume no duplicate exists in the array.

Discuss

java code : 找到那个 pivot ，然后二分查找， 找pivot的算法复杂度也是 O（logn）：

public class Solution {
    public int search(int[] A, int target) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
       if(A == null)
            return -1;
        int lhs = 0, rhs = A.length - 1;
        int pos = 1;
        int mid = lhs;
        if(A[lhs] <= A[rhs])
        {
        	int index = Arrays.binarySearch(A, target);
        	if(index < 0)
        		return -1;
        	return index;
        }
        while(A[lhs] >= A[rhs])
        {
        	if(rhs - lhs == 1)
        	{
        		pos = rhs;
        		break;
        	}
        	mid = (lhs + rhs) >> 1;
        	if(A[mid] >= A[lhs])
        		lhs = mid;
        	else if(A[mid] <= A[rhs])
        		rhs = mid;
        }
        int res1 = binarysearch(A,target,0,pos-1);
        int res2 = binarysearch(A,target,pos,A.length -1);
        if(res1 != -1)
        	return res1;
        if(res2 != -1)
        	return res2;
        return -1;
    }
    public int binarysearch(int[] array, int key, int st, int end)
	{
		int lhs = st, rhs = end;
		if(st == end)
		{
			if(array[st] == key)
				return st;
			return -1;
		}
		while(lhs <= rhs)
		{
			int mid = (lhs + rhs) >> 1;
			if(array[mid] == key)
				return mid;
			else if(array[mid] < key)
				lhs = mid + 1;
			else rhs = mid - 1;
		}
		return -1;
	}
}

Search in Rotated Sorted Array II

  Total Accepted: 1164  Total Submissions: 4138 My Submissions

Follow up for "Search in Rotated Sorted Array":
What if duplicates are allowed?

Would this affect the run-time complexity? How and why?

Write a function to determine if a given target is in the array.

有重复的情况，只能朴素查找了，会影响算法的复杂度，因为会影响找pivot的那个算法

java code :

public class Solution {
    public boolean search(int[] A, int target) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        if(A == null)  
            return false;  
        int lhs = 0, rhs = A.length - 1;  
        int pos = 1;  
        int mid = lhs;  
        if(A[lhs] <= A[rhs])  
        {  
             Arrays.sort(A);
            int index = Arrays.binarySearch(A, target);  
            if(index < 0)  
                return false;  
            return true;  
        }  
        while(A[lhs] >= A[rhs])  
        {  
            if(rhs - lhs == 1)  
            {  
                pos = rhs;  
                break;  
            }  
            mid = (lhs + rhs) >> 1;  
            if(A[mid] == A[lhs] && A[lhs] == A[rhs])
            {
                Arrays.sort(A);
                int index = Arrays.binarySearch(A, target);  
                if(index < 0)  
                    return false;  
                return true;  
            }
            if(A[mid] >= A[lhs])  
                lhs = mid;  
            else if(A[mid] <= A[rhs])  
                rhs = mid;  
        }  
        int res1 = binarysearch(A,target,0,pos-1);  
        int res2 = binarysearch(A,target,pos,A.length -1);  
        if(res1 != -1)  
            return true;  
        if(res2 != -1)  
            return true;  
        return false;  
    }  
    
    public int binarysearch(int[] array, int key, int st, int end)  
    {  
        int lhs = st, rhs = end;  
        if(st == end)  
        {  
            if(array[st] == key)  
                return st;  
            return -1;  
        }  
        while(lhs <= rhs)  
        {  
            int mid = (lhs + rhs) >> 1;  
            if(array[mid] == key)  
                return mid;  
            else if(array[mid] < key)  
                lhs = mid + 1;  
            else rhs = mid - 1;  
        }  
        return -1;  
    }
    
}