LeetCode Search in Rotated Sorted Array II

在

Search in Rotated Sorted Array I

  基础上改的，仔细分析发现 

和剑指offer上的寻找旋转数组的最小数字还不一样。那题因为不用另引进一个target，所以判断时更好判断，这题还要考虑target更复杂一点。有一点要注意的是  if (A[i]==A[mid])为什么i = mid + 1; 因为A[i]不等于A[j]，所以A[mid]不等于A[j]，而所有取值为 非A[i]的值 只能在A[mid+1]到A[j]（因为A[i]到A[mid]全相等，这样才能保证数组是旋转的，说白了，就是数组只能有一处上升起或下降，在后面就不能在前面了）

。整个时间复杂度最坏是还是O(N)。平均是O(log(N))。程序如下：

bool bisearch(int *arr,int start,int end,int value)  
{  
	int mid;
	while(start<=end)  
	{  
		if (arr[start]==arr[end])
		{
			if(arr[start]==value)
				return true;
			else
				return false;
		}
		mid = (start + end)>>1;  
		if (arr[mid]==value)  
		{  
			return true;  
		}  
		else  
		{  
			if (arr[mid]>value)  
				end = mid -1;  
			else  
				start = mid + 1;  
		}  
	}  
	return false;  
}  
bool gensearch(int *arr,int start,int end,int value)
{
	for (int i=start;i<=end;i++)
	{
		if(arr[i]==value)
			return true;
	}
	return false;
}
bool search(int A[], int n, int target) {  
	if (A[0]<A[n-1])  
		return bisearch(A,0,n-1,target); 
	if (n==1&&A[0]==target)   
		return true;  
	int i=0,j=n-1;  
	while(i<j)  
	{  
		if(A[i]==target||A[j]==target)  
			return true;
		if (A[i]==A[j])
		{
			return gensearch(A,i+1,j-1,target);
		}
		int mid = (i+j)>>1;  
		if(A[mid]==target)  
			return true;  
		if (A[i]==A[mid])//因为A[i]不等于A[j]，所以A[mid]不等于A[j]，而所有取值为 非A[i]的值 只能在A[mid+1]到A[j]（因为A[i]到A[mid]全相等，这样才能保证数组是旋转的，说白了，就是数组只能有一处上升起或下降，在后面就不能在前面了）
		{
			i = mid + 1;
		}
		else
		{
			if (A[i]<A[mid])  
			{  
				if (target>A[i]&&target<A[mid])  
				{  
					return bisearch(A,i+1,mid-1,target);  
				}  
				else  
					i = mid + 1;  
			}  
			else  
			{  
				if (target>A[mid]&&target<A[i])  
				{  
					i = mid + 1;//  
				}  
				else  
					j = mid - 1;
			}  
		}
		
	}  
	return false;  
}  

剑指offer的旋转数组中的最小数字程序如下：

int MinInOrder(int* numbers, int index1, int index2);

int Min(int* numbers, int length)
{
	if(numbers == NULL || length <= 0)
		throw new std::exception("Invalid parameters");

	int index1 = 0;
	int index2 = length - 1;
	int indexMid = index1;
	while(numbers[index1] >= numbers[index2])
	{
		// 如果index1和index2指向相邻的两个数，
		// 则index1指向第一个递增子数组的最后一个数字，
		// index2指向第二个子数组的第一个数字，也就是数组中的最小数字
		if(index2 - index1 == 1)
		{
			indexMid = index2;
			break;
		}

		// 如果下标为index1、index2和indexMid指向的三个数字相等，
		// 则只能顺序查找
		indexMid = (index1 + index2) / 2;
		if(numbers[index1] == numbers[index2] && numbers[indexMid] == numbers[index1])
			return MinInOrder(numbers, index1, index2);

		// 缩小查找范围
		if(numbers[indexMid] >= numbers[index1])
			index1 = indexMid;
		else if(numbers[indexMid] <= numbers[index2])
			index2 = indexMid;
	}

	return numbers[indexMid];
}

int MinInOrder(int* numbers, int index1, int index2)
{
	int result = numbers[index1];
	for(int i = index1 + 1; i <= index2; ++i)
	{
		if(result > numbers[i])
			result = numbers[i];
	}

	return result;
}