LeetCode 33，81. Search in Rotated Sorted Array i, ii

1. 题目描述

33

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.

81

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.

2. 解题思路

这是一个有序数组， 所以我们可以尝试使用二分的思路去解决这个问题， 不过需要注意一个问题，使用二分法的时候， 边界问题的判断。 这里由于不太记得住二分法究竟怎么写了， 于是在自己的代码中加了一个补丁， 特别判断一下 start == stop - 1 的情形

而对于 81 题， 由于允许重复， 我们只需要对有重复部分区域采用遍历即可。

3. code

3.1 code 33

class Solution {
public:
int search(vector<int>& nums, int target) {
return helper(nums, 0, nums.size() - 1, target);
}
private:
// x -->  [start, stop];
int helper(vector<int>& nums, int start, int stop, int target){
int res = -1;
while (start <= stop){
int mid = start + ((stop - start) >> 1);
if (nums[mid] == target)
return mid;

if (start == stop)
break;

// 我是补丁
if (start == stop - 1){
if (nums[stop] == target)
return stop;
break;
}

if (nums[start] < nums[mid]){
if (nums[start] <= target && nums[mid] > target)
stop = mid - 1;
else
start = mid + 1;
}
else{
if (nums[mid] < target && nums[stop] >= target)
start = mid + 1;
else
stop = mid - 1;
}
}

return res;
}
};

3.2 81 code

class Solution {
public:
bool search(vector<int>& nums, int target) {
return helper(nums, 0, nums.size() - 1, target) >= 0;
}

private:
// x -->  [start, stop];
int helper(vector<int>& nums, int start, int stop, int target){
int res = -1;
while (start <= stop){
int mid = start + ((stop - start) >> 1);
if (nums[mid] == target)
return mid;

if (start == stop)
break;

// 我是补丁
if (start == stop - 1){
if (nums[stop] == target)
return stop;
break;
}

// 遍历搜索
if (nums[start] == nums[mid] || nums[stop] == nums[mid] || nums[start] == nums[stop]){
for (int i = start; i != stop + 1; i++){
if (nums[i] == target)
return i;
}

return -1;
}

if (nums[start] < nums[mid]){
if (nums[start] <= target && nums[mid] > target)
stop = mid - 1;
else
start = mid + 1;
}
else{
if (nums[mid] < target && nums[stop] >= target)
start = mid + 1;
else
stop = mid - 1;
}
}

return res;
}
};

4. 大神解法

4.1 33 demo1 先修复旋转数组， 再查找

这段代码， 主要是通过先利用二分查找， 找到最小值的位置， 然后根据这个最小值的位置， 可以推算出该旋转数组和该数组之间的转化关系， 利用二分查找即可， what a brilliant solution!!!

class Solution {
public:
int search(int A[], int n, int target) {
int lo=0,hi=n-1;
// find the index of the smallest value using binary search.
// Loop will terminate since mid < hi, and lo or hi will shrink by at least 1.
// Proof by contradiction that mid < hi: if mid==hi, then lo==hi and loop would have been terminated.
while(lo<hi){
int mid=(lo+hi)/2;
if(A[mid]>A[hi]) lo=mid+1;
else hi=mid;
}
// lo==hi is the index of the smallest value and also the number of places rotated.
int rot=lo;
lo=0;hi=n-1;
// The usual binary search and accounting for rotation.
while(lo<=hi){
int mid=(lo+hi)/2;
int realmid=(mid+rot)%n;
if(A[realmid]==target)return realmid;
if(A[realmid]<target)lo=mid+1;
else hi=mid-1;
}
return -1;
}
};

4.2 33 demo2 思路和我们的一致

public class Solution {
public int search(int[] A, int target) {
int lo = 0;
int hi = A.length - 1;
while (lo < hi) {
int mid = (lo + hi) / 2;
if (A[mid] == target) return mid;

if (A[lo] <= A[mid]) {
if (target >= A[lo] && target < A[mid]) {
hi = mid - 1;
} else {
lo = mid + 1;
}
} else {
if (target > A[mid] && target <= A[hi]) {
lo = mid + 1;
} else {
hi = mid - 1;
}
}
}
return A[lo] == target ? lo : -1;
}
}

4.3 81 demo

由于当发生重复的时候， A[m] == A[l], 可以将 l++， 因为这个l 的值会在后面的内容中再次出现的。。。

bool search(int A[], int n, int key) {
int l = 0, r = n - 1;
while (l <= r) {
int m = l + (r - l)/2;
if (A[m] == key) return true; //return m in Search in Rotated Array I
if (A[l] < A[m]) { //left half is sorted
if (A[l] <= key && key < A[m])
r = m - 1;
else
l = m + 1;
} else if (A[l] > A[m]) { //right half is sorted
if (A[m] < key && key <= A[r])
l = m + 1;
else
r = m - 1;
} else l++;
}
return false;
}