[LeetCode]33. Search in Rotated Sorted Array

33. Search in Rotated Sorted Array

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.

分析

题中给出的序列是由两个已经排序的序列合并而成的，并且后面的有序序列的所有数都是比第一个序列的首元素小，这里有两种思路：

1. 找到这个pivot所在的位置，然后用target和这个pivot所在元素比较，找出target在前半段还是后半段范围内，然后在这个找到的范围内用二分法查找

2. 直接使用二分查找法，只是这里的二分法稍微复杂了点。
   如果nums[first] <= nums[mid]，那么first到mid之间是有序的，这个时候判断target是否在first...mid之间，在的话last=mid，如果不在，那肯定在mid+1...last之间，first=mid+1;
   否则nums[first] > nums[mid]，那么pivot在first…mid之间，即mid…last之间是有序的，这个时候判断target是否在mid...last之间，在的话first=mid+1，如果不在，那肯定在first...mid之间，last=mid

源码

方法1：先找pivot，然后用二分法

    int binarySearch(vector<int>& nums, int start, int end, int target) {        // 递归二分法        // if((end - start) == 1 || end == start) {        //     if(nums[start] == target) return start;        //     else if(nums[end] == target) return end;        //     else return -1;        // }        // int middle = (end + start) / 2;        // if(nums[middle] == target) return middle;        // else if(nums[middle] < target) start = middle;        // else end = middle;        // return binarySearch(nums,start,end,target);        //循环二分法        int middle, low = start, high = end;        int ret = -1;        while(low <= high) {            middle = (low + high) / 2;            if(nums[middle] == target) {                ret = middle;                break;            } else if(nums[middle] < target) {                low = middle + 1;            } else {                high = middle - 1;            }        }        return ret;    }    //寻找pivot    int indexOfPivot(vector<int>& nums) {        int index = -1;        if(nums.size() < 2) return index;        for(int i = 1; i < nums.size(); i++) {            if(nums[i] < nums[i-1]) {//当前数比前一数小，因为没有重复数，所以可以直接判断                index = i;                break;            }        }        return index;    }    int search(vector<int>& nums, int target) {        if(nums.size() == 0) return -1;        int pivot = indexOfPivot(nums);        if(pivot == -1) return binarySearch(nums, 0, nums.size() - 1, target);//没有pivot，直接二分法        else if(nums[pivot] <= target && target <= nums[nums.size()-1]) return binarySearch(nums,pivot,nums.size() - 1, target);        else if(nums[pivot - 1] >= target) return binarySearch(nums,0,pivot - 1, target);        else return -1;    }

方法二：直接二分法

    int search(const vector<int>& nums, int target) {        int first = 0, last = nums.size();        while (first != last) {            const int mid = first + (last - first) / 2;            if (nums[mid] == target)                return mid;            if (nums[first] <= nums[mid]) { // 因为序列没有重复元素，这里等号不需要也可以; first...mid之间都是顺序的                if (nums[first] <= target && target < nums[mid])                    last = mid;                else                    first = mid + 1;            } else { // nums[first] > nums[mid] 说明序列扭转点发生在first...mid之间，但是mid之后的数是顺序的                if (nums[mid] < target && target <= nums[last-1])                    first = mid + 1;                else                    last = mid;            }        }        return -1;    }