二叉搜索树与二分查找--08-[剑]旋转数组的最小数字[简单]

力扣

力扣

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一个旋转，该数组的最小值为1。  

示例 1：

输入：[3,4,5,1,2]

输出：1

示例 2：

输入：[2,2,2,0,1]

输出：0

思路

最直观的思路是从前到后扫描，遇到递减就找到了最小值。时间复杂度为O(n)。但这显然没有用到旋转数组的性质。

class Solution {
public:
    int minArray(vector<int>& numbers) {
        if(numbers.empty()) return NULL;
        int ret=numbers[0];
        for(int i=0;i<numbers.size();i++)
            if(numbers[i]<ret)
                ret=numbers[i];
        return ret;
    }
};

观察到旋转后是两个排序数组，而且前面子数组的值都大于后面子数组的值，最小的元素刚好是分界线，因此可使用二分查找的思路完成(O(logn))。

即二分查找时，如果中间元素大于头部元素和尾部元素，则说明该元素在第一个数组，下一次二分查找应该查找后面的元素。反之如果小于尾巴和头部，则下一次二分应查找前面的元素。

注意处理0个元素旋转(即单调递增)，和数组中有重复元素的情况(1,0,1,1,1. 此时只能顺序查找)。

答案

class Solution {
public:
    int minArray(vector<int>& numbers) {
        if(numbers.size()==1)
            return numbers[0];
        int low=0;
        int high=numbers.size()-1;
        int left_flag=numbers[0];
        int right_flag=numbers[high];
        int mid=low; //处理单调递升的情况 直接跳过while
        while(numbers[low]>=numbers[high]) {
            if((high-low)==1)   
                return numbers[high];
            mid=(low+high)/2;
            //如果low high mid三个指向的数字大小相同 只能顺序查找
            if(numbers[low]==numbers[high]&&numbers[high]==numbers[mid]){
                return minInOrder(numbers);
            }
            else if(numbers[mid]>=numbers[low])
                low=mid;
            else if(numbers[mid]<=numbers[high])
                high=mid;
        }
        return numbers[mid];
    }
    int minInOrder(vector<int>& numbers) {
        for(int i=1;i<numbers.size();i++)
            if(numbers[i]<numbers[i-1])
                return numbers[i];
        return numbers[0];
    }
};