算法系列——寻找旋转排序数组中的最小值

Posted 2022-01-11 BridgeGeorge

题目

题目

问题

已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：
若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]
若旋转 7 次，则可以得到 [0,1,2,4,5,6,7]
注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。

给你一个元素值 互不相同 的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。

示例 1：

输入：nums = [3,4,5,1,2]
输出：1
解释：原数组为 [1,2,3,4,5] ，旋转 3 次得到输入数组。
示例 2：

输入：nums = [4,5,6,7,0,1,2]
输出：0
解释：原数组为 [0,1,2,4,5,6,7] ，旋转 4 次得到输入数组。
示例 3：

输入：nums = [11,13,15,17]
输出：11
解释：原数组为 [11,13,15,17] ，旋转 4 次得到输入数组。

解答

class Solution 
    public int findMin(int[] nums) 
        int low = 0;
        int high = nums.length - 1;
        while (low < high) 
            //保证low high 都有机会和最小值重合
            int mid = low + (high - low) / 2;
            //mid  min 位置 位于最小值左侧 ，
            if (nums[mid] > nums[high]) 
                low = mid+1;
            
            //min  mid 位置位于最小值右侧
            else 
                high = mid;
            
        
        return nums[high];
    

​​​​​​​

class Solution 
    public int search(int[] nums, int target) 
        //如果 nums[mid]> target 
        //将数组一分为二，其中一定有一个是有序的，
        //另一个可能是有序，也能是部分有序。
        //此时有序部分用二分法查找。无序部分再一分为二，其中一个一定有序，另一个可能有序，可能无序。就这样循环.
        int low =0;
        int high=nums.length-1;
        while(low<=high)
            int mid=low+(high-low)/2;
            if(nums[mid]==target)
                return mid;
            
            //[low,mid]有序 [mid+1,high] 不一定有序
            if(nums[low]<=nums[mid])
                //[low,mid-1] 找 
                if(nums[low]<=target&&target<nums[mid])
                    high=mid-1;
                else
                    low=mid+1;
                
            
           //[0,mid]不一定有序 [mid+1,high] 有序
            else
                if(nums[mid]<target&&target<=nums[high])
                    low=mid+1;
                else
                    high=mid-1;
                
            
        
        return -1;