[Leetcode学习]Find Minimum in Rotated Sorted Array(旋转数组找最小值)

问题：

难度：medium

说明：

给一个二维数组，已经排序，而且里面无重复值，但数组可能是旋转状态。

相关算法：

Find Minimum in Rotated Sorted Array II(旋转数组找最小值)：https://blog.csdn.net/qq_28033719/article/details/107586131

输入案例：

Example 1:
Input: [3,4,5,1,2] 
Output: 1

Example 2:
Input: [4,5,6,7,0,1,2]
Output: 0

我的代码：

有两个，一个是最近更新的更加简单的，一个是以前的。

class Solution {
    public int findMin(int[] nums) {
        int begin = 0;
        int end = nums.length - 1;
        int len = nums.length;
        
        A:while(end > begin) {
            int mid = begin + end >> 1;
            if(nums[mid] < nums[(mid - 1 + len) % len]) return nums[mid];
            else if(nums[mid] > nums[(mid + 1) % len]) return nums[(mid + 1) % len];
            else if(nums[mid] > nums[end]) begin = mid + 1;
            else if(nums[mid] < nums[end]) end = mid - 1;
        }
        return nums[begin];
    }
    
    // 反过来找唯一峰值，因为找最小值，意味着存在一个峰值，使他两边的值都小于他
//     public int findMin(int[] nums) {
//         int left = 0;
//         int right = nums.length - 1;
//         int length = nums.length;
        
//         int mid = -1;
//         while(right >= left) {
//             mid = (left + right) >> 1;
            
//             int bound = 0;
//             if(mid - 1 < 0) bound = 1;
//             else if(mid + 1 >= length) bound = 2;
            
//             if(bound == 1) return nums[length - 1];
//             else if(bound == 2) return nums[0];
            
//             boolean leftBigger = nums[mid - 1] > nums[mid];
//             boolean rightBigger = nums[mid] < nums[mid + 1];
            
//             if(leftBigger) return nums[mid];
//             else if(!leftBigger && !rightBigger) return nums[mid + 1];
//             else if(nums[mid] < nums[left] && nums[mid] < nums[right]) right = mid;
//             else left = mid + 1;
//         }
        
//         return left;
//     }
    
}