# 33. Search in Rotated Sorted Array

Suppose an array sorted in ascending order 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.

Your algorithm‘s runtime complexity must be in the order of O(log n).

Example 1:

```Input: nums = [`4,5,6,7,0,1,2]`, target = 0
Output: 4
```

Example 2:

```Input: nums = [`4,5,6,7,0,1,2]`, target = 3
Output: -1```

this is my first code, it can‘t satisfy the last condition:

```class Solution {
public:
int search(vector<int>& nums, int target) {
int len = nums.size();
if (len == 0) return -1;
bool flag = false;
if (target < nums[0]) {
for (int i = len-1; i > 0; --i) {
if (nums[i] == target) {
flag = true;
return i;
}
}
} else {
for (int i = 0; i < len; ++i) {
if (nums[i] == target) {
flag = true;
return i;
}

}
}
if (!flag) {
return -1;
}
}
};```

this is the right way to use binary search:

```class Solution {
public:
int search(vector<int>& nums, int target) {
int len = nums.size();
if (len == 0) return -1;
int l = 0;
int r = len - 1;
while (l <= r) {
int m = (l + r) / 2;
if (nums[m] == target) return m;
if (nums[m] > nums[r]) {
if (target < nums[m] && target >= nums[l]) {
r = m - 1;
} else {
l = m + 1;
}
} else if (nums[m] < nums[l]) {
if (target <= nums[r] && target > nums[m]) {
l = m + 1;
} else {
r = m -1;
}
} else {
if (target < nums[m]) {
r = m -1;
} else {
l = m + 1;
}
}
}
return -1;
}
};
```

Runtime: 8 ms, faster than 25.99% of C++ online submissions for Search in Rotated Sorted Array.

but this way cost more time before the previous way.

33. Search in Rotated Sorted Array

(0)
(0)

0条