剑指 Offer 11. 旋转数组的最小数字把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。_11.旋转数组的最小数字把一个数组最开始的若干个元素搬到数组的末尾,我们称之为-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_34823218/article/details/109460529

这篇博客探讨了如何在经过旋转的递增排序数组中找到最小元素。通过分析旋转特性，可以采用二分查找的方法有效地定位到最小值。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

package SwordOffer;
/**
* @Description: 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如，数组 [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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/xuan-zhuan-shu-zu-de-zui-xiao-shu-zi-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
* @Param:
* @return:
* @Author: lvhong
* @Date:
* @E-mail lvhong282@163.com
*/
public class lab11easy {
    class Solution {

        //二分法
        //时间复杂度O(log2n）   空间复杂度O(1)

        // public int minArray(int[] numbers) {
        //     int length = numbers.length;
        //     int left = 0;
        //     int right =length-1;

        //     while(left<right){
        //         int mid = left+(right-left)/2;
        //         if(numbers[mid]>numbers[right]){
        //             left=mid+1;
        //         }else if(numbers[mid]<numbers[right]){
        //             right=mid;
        //         }else{
        //             right--;
        //         }
        //     }
        //     return numbers[left];
        // }

        //标准递归分治
        //时间复杂度O(n）   空间复杂度O(1)

        // public int minArray(int[] nums) {
        //     int len = nums.length;
        //     return minArray(nums, 0, len - 1);
        // }

        // private int minArray(int[] nums, int left, int right) {
        //     if (left + 1 >= right) {
        //         return Math.min(nums[left], nums[right]);
        //     }

        //     if (nums[left] < nums[right]) {
        //         return nums[left];
        //     }
        //     int mid = left + (right - left) / 2;
        //     return Math.min(minArray(nums, left, mid - 1), minArray(nums, mid, right));
        // }


        //检测到相等时遍历
        //时间复杂度O(n）   空间复杂度O(1)

        
        // public int minArray(int[] numbers) {
        //      int length = numbers.length;
        //      int left = 0;
        //      int right =length-1;

        //      while(left<right){
        //          int mid = left+(right-left)/2;
        //          if(numbers[mid]>numbers[right]){
        //              left=mid+1;
        //          }else if(numbers[mid]<numbers[right]){
        //              right=mid;
        //          }else{
        //              int pos=0;
        //             for(int i=1;i<length;i++)  {
        //                 if(numbers[pos]>numbers[i]){
        //                 pos=i;
        //                 }
        //              }
        //              return numbers[pos];
        //          }
        //      }
        //      return numbers[left];
        //  }

//遍历
        //时间复杂度O(n）   空间复杂度O(1)

        public int minArray(int[] numbers) {
            int pos=0;
            int length = numbers.length;
            for(int i=1;i<length;i++)  {
                if(numbers[pos]>numbers[i]){
                    pos=i;
                }
            }
            return numbers[pos];
        }
    }
}