牛客JZ11-旋转数组的最小数字

问题描述

有一个长度为 n 的非降序数组，比如[1,2,3,4,5]，将它进行旋转，即把一个数组最开始的若干个元素搬到数组的末尾，变成一个旋转数组，比如变成了[3,4,5,1,2]，或者[4,5,1,2,3]这样的。请问，给定这样一个旋转数组，求数组中的最小值。
数据范围：1≤n≤10000，数组中任意元素的值：0≤val≤10000
要求：空间复杂度：O（1），时间复杂度：O（logn）

题目链接: https://www.nowcoder.com/practice/9f3231a991af4f55b95579b44b7a01ba?tpId=13&tqId=11159&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking

示例

示例1
输入：[3,4,5,1,2]
返回值：1

示例2
输入：[3,100,200,3]
返回值：3

具体思路

  NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
  数组问题，本质其实是一个求最小值的问题。

思路一

  理论上，遍历一次即可，但是我们可以根据题面使用稍微高效且更简单一点的做法。按照要求，要么是一个非递减排序的数组（最小值在最开始），要么是一个旋转（最小值在中间某个地方）。而且，旋转之后有个特征，就是在遍历的时候，原始数组是非递减的，旋转之后，就有可能出现递减，引起递减的数字，就是最小值。

思路二

  采用二分查找的方式进行定位。
  定义首尾下标，因为是非递减数组旋转，所以旋转最后可以看成两部分，前半部分整体非递减，后半部分整体非递减，前半部分整体大于后半部分。所以，我们假设如下定义，left指向最左侧，right指向最右侧，mid为二分之后的中间位置。
  则，a[mid]>=a[left]，说明mid位置在原数组前半部分，进一步说明，目标最小值，在mid的右侧，让left=mid。

   a[mid]<a[left]，说明mid位置在原数组后半部分，进一步说明，目标最小值，在mid的左侧，让right=mid。

   这个过程会让[left,right]区间缩小，这个过程中，left永远在原数组前半部分，right永远在原数组的后半部分，而范围会一直缩小，当left和right相邻时，right指向的位置，就是最小元素的位置。
   但是，因为题目说的是非递减，也就意味着数据允许重复，因为有重复数，就可能会有a[left]==a[mid]==a[right]的情况，我们就无法判定数据在mid左侧还是右侧。（注意，只要有两者不相等，我们就能判定应该如何缩小范围）

代码实现

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param nums int整型vector 
     * @return int整型
     */
    int minNumberInRotateArray(vector<int>& nums) {
        // write code here
        if(nums.empty())   //判断数组是否为空
        {
            return 0;
        }

        for(int i=0;i<nums.size()-1;i++)
        {
            if(nums[i]>nums[i+1])   //前一个数比后一个数大就返回后面一个数
            {
                return nums[i+1];
            }
        }
        return nums[0];
    }
};

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param nums int整型vector 
     * @return int整型
     */
    int minNumberInRotateArray(vector<int>& nums) {
        // write code here
        if(nums.empty())   //判断数组是否为空
        {
            return 0;
        }

        int left=0;    //左下标
        int right=nums.size()-1;  //右下标
        int mid=0;  //中间下标

        while(nums[left]>=nums[right])  //保证是旋转的特性
        {
            if(right-left==1)
            {
                mid=right;
                break;
            }
            
            //mid=(right+left)/2;     //直接用(right+left)/2 可能会导致溢出
           mid=left+(right-left)/2;    
            if((nums[left]==nums[mid])&&(nums[mid]==nums[right]))
            {
                int result= nums[left];
                for(int i=left+1;i<right;i++)
                 {
                    if(result>nums[i])   //前一个数比后一个数大就返回后面一个数
                    {
                         result= nums[i];
                    }
                } 
                return result;
            }
            if(nums[mid]>=nums[left])   //中间的数比左边大，目标最小值则在mid右侧
            {
                left=mid;
            }
            else                       //中间的数比左边小，目标最小值则在mid左侧
            {
                right=mid;
            }
        }
        return nums[mid];
    }
};