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;
}