旋转数组的最小数字(Java实现)

最近一直在学习算法相关的知识。下面，分享一道源自于《剑指offer》的题目。
题目描述：把一个数组最开始的若干个元素搬到数组末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如，数组{3，4，5，1，2}为{1，2，3，4，5}的一个旋转，该数组的最小值为1。
附上以下四种解法：

解法一：从头到尾遍历数组一次，即可找到最小元素。时间复杂度为o(n)

public class test {
    public static void main(String[] args) {
        int[] a = {1, 0, 1, 1, 1};
        System.out.println(Min(a));

    }

 public static int Min(int[] a) {
        if (a == null || a.length < 0) {
            throw new NegativeArraySizeException();
        }

        int min = a[0];
        for (int i = 1; i < a.length - 1; i++) {
            if (a[i] < min) {
                return a[i];
            }
        }
        return -1;
    }
}

解法二：将源数组按从小到大的顺序进行排序，第一个数字即为我们要查找的。

import java.util.Arrays;
public class test2 {
    public static void main(String[] args) {
        int[] a = {3, 4，5, 1, 2};
        System.out.println(Min(a));

    }

public static int Min(int[] a){
        Arrays.sort(a);//使用Arrays中的sort方法对该数组排序，无须自己写排序方法
        return a[0];
    }
 }

解法三：
思路：（1）类比C语言中的指针概念。我们定义两个变量low(p1)和high(p2)，分别指向数组中第1个元素和第5个元素。由于low和high中间的数字5大于low指向的数字，从而中间的数字在第一个子数组中。接下来，让low指向中间的数字5。
（2）此时，low指向数字5，high指向数字2。中间的数字1小于high指向的数字，且在第二个子数组中。然后，让high指向中间的数字。
（3）此时low和high指向两个相邻的数字，则high指向的即为我们要查找的。
附上图解：

（有阴影的部分为第二个子数组）

public static int Min(int[] a) {
        if (a == null || a.length < 0) {
            throw new NegativeArraySizeException();
        }

        int low = 0;
        int high = a.length - 1;
        int mid = 0;

        while (a[low] >= a[mid]) {


            /* * 此时，表示low指针已经指向第一个递增子数组的末尾。high指针指向第二个递增数组的开头
             * high指针指向的数组就是我们要查找的
             * */
            if (high - low == 1) {
                mid = high;
                break;
            }

            mid = low + (high - low) / 2;
            if (a[mid] >= a[low]) {
                low = mid;
            } else if (a[mid] <= a[high]) {
                high = mid;
            }
        }

        return a[mid];
    }
}

解法四 ：在解法三的基础上，当我们遇到low（p1）、high(p2)和mid指向的数字都相等时，如这样的数组{1，0，1，1，1}。我们就无法确定中间的数字1是属于第一个递增子数组还是第二个递增子数组。也就无法移动两个指针来缩小查找的范围了。

所以，只能采用顺序查找，即解法二的方法。

 public static int Min(int[] a){
        
        int low=0;
        int high=a.length-1;
        int mid=0;

        while(a[low]>=a[high]){
            if(a.length<0||a==null){
                throw new  NegativeArraySizeException();
            }

            if(high-low==1){
                mid=high;
                break;
            }

            mid=low+(high-low)/2;
            //当low、high、mid指向的三个数字相等时，采取顺序查找方法
            if((a[low]==a[high])&&(a[mid]==a[low])){
                return MinInOrder(a,low,high);
            }

            if (a[mid] >= a[low]) {
                low = mid;
            } else if (a[mid] <= a[high]) {
                high = mid;
            }
        }
        return a[mid];
        }

        //顺序查找
    public static int MinInOrder(int[] a,int low,int high){
        int min=a[low];
        for(int i=1;i<a.length-1;++i){
            if(a[i]<min){
                return a[i];
            }
        }
        return -1;
    }