leetcode33. 搜索旋转排序数组

题目描述

假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。
你可以假设数组中不存在重复的元素。
你的算法时间复杂度必须是 O(log n) 级别。

示例

示例1
输入： nums = [4,5,6,7,0,1,2], target = 0
输出： 4

示例 2
输入: nums = [4,5,6,7,0,1,2], target = 3
输出: -1

题解

思路： 先找到最值将旋转数组分成两段有序数组，接下来在有序数组中查找目标值。
1.先找到 旋转排序数组中的最小值的索引，由此可以将数组分为升序的两段。
2.根据 nums[0] 与 target 的关系判断 target 在左段还是右段，再对升序数组进行二分查找即可。
参考于作者：sweetiee
链接：https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/duo-si-lu-wan-quan-gong-lue-bi-xu-miao-dong-by-swe/

代码

class Solution {
public:
    //, int target
    int search(vector<int>& nums, int target) {
        int result;
        int len = nums.size();
        if(len==1){
            if(nums[0]==target) return 0;
            else return -1;
        }
        int minInd = minIndex(nums);
        //cout << minInd << endl;
        if (target <= nums[len-1])
            result = binSearch(nums, minInd, len-1, target);
        else
            result = binSearch(nums, 0, minInd-1, target);
        return result;
    }

    int minIndex(vector<int>& nums) {
        int len = nums.size();
        int lo = 0;
        int hi = len - 1;
        int mi;
        int minInd;
        while (lo < hi) {
            mi = (lo + hi) >> 1;
            //此判断语句为判断出口
            //当mi==lo时，表明lo和hi的距离为0或者1
            //最小值为nums[lo]或者nums[hi]
            if (mi == lo) {
                if (nums[lo] < nums[hi]) minInd = lo;
                else minInd = hi;
                break;
            }
            //由于数组中不存在重复元素
            //此种情况下，最小值存在于(mi,hi]范围内(反正法可以证明)
            if (nums[lo] < nums[mi] && nums[mi] > nums[hi]) {
                lo = mi + 1;
            }
            //此种情况下，最小值存在于(lo,mi]范围内(反正法可以证明)
            else if (nums[lo] > nums[mi] && nums[mi] < nums[hi]) {
                hi = mi;
            }
            //此种情况下，最小值存在于[lo,mi)范围内
            //此时lo,mi,hi为单调递增
            else if (nums[lo] < nums[mi] && nums[mi] < nums[hi]) {
                hi = mi;
            }
        }
        return minInd;
    }

    int binSearch(vector<int>& nums, int lo, int hi, int e) {
        while (lo < hi) {
            int mi = (lo + hi) >> 1;
            if (e < nums[mi]) hi = mi;
            else if (nums[mi] < e) lo = mi + 1;
            else return mi;
        }
        if(e==nums[lo]) return lo;
        else return -1;
    }
};

笔记

由于leetcode编译器版本的不同，若minIndex函数写成如下形式，

int minIndex(vector<int>& nums) {
        int len = nums.size();
        int lo = 0;
        int hi = len - 1;
        int mi;
        while (lo < hi) {
            mi = (lo + hi) >> 1;
            if (mi == lo) {
                if (nums[lo] < nums[hi]) return lo;
                else return hi;
            }
            if (nums[lo] < nums[mi] && nums[mi] > nums[hi]) {
                lo = mi + 1;
            }
            else if (nums[lo] > nums[mi] && nums[mi] < nums[hi]) {
                hi = mi;
            }
            else if (nums[lo] < nums[mi] && nums[mi] < nums[hi]) {
                hi = mi;
            }
        }
    }

输出会报错，但是在VS2019中不会报错。