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.