原題連結在此

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.

可以利用二分查詢的思路，達到O(logN)的時間複雜度。

這樣排序的特點就是，存在一個最小值（比如上面例子裡的0），這個最小值的左半部分的最小值（比如上面例子裡的4），大於：這個最小值的右半部分（包括他本身）的最大值（比如上面例子裡的2）。可以利用這一點來找這個最小值。

class Solution {
public:
	int search(vector<int>& nums, int target) {
		int low = 0, high = nums.size() - 1;
		int mid = 0;
		while (low < high) {
			mid = (low + high) / 2;
			if (nums[mid] > nums[high])
				low = mid + 1;
			else
				high = mid;
		}
		int smallest = low;

		if (nums.size() == 0) {
			return -1;
		} else if (target >= nums[smallest] && target <= nums[nums.size() - 1]) {
			low = smallest;
			high = nums.size() - 1;
		} else if (target >= nums[0] && target <= nums[smallest - 1]) {
			low = 0;
			high = smallest - 1;
		} else {
			return -1;
		}

		while (low <= high) {
			mid = (low + high) / 2;
			if (nums[mid] == target) return mid;
			if (nums[mid] < target) low = mid + 1;
			else high = mid - 1;
		}

		return -1;
	}
};