旋转数组的最小数字 java 牛客网可以通过，但是有问题

一、题目描述

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

1)从头到尾遍历数组一次，我们就能找出最小的元素。这种思路的时间复杂度显然是O(n)。但是这个思路没有利用输入的旋转数组的特性，肯定达不到面试官的要求。

我们注意到旋转之后的数组实际上可以划分为两个排序的子数组，而且前面的子数组的元素都大于或者等于后面子数组的元素。我们还注意到最小的元素刚好是这两个子数组的分界线。在排序的数组中我们可以用二分查找法实现O(logn)的查找。

 

二、解题思路

Step1.和二分查找法一样，我们用两个指针分别指向数组的第一个元素和最后一个元素。

Step2.接着我们可以找到数组中间的元素：

　　如果该中间元素位于前面的递增子数组，那么它应该大于或者等于第一个指针指向的元素。此时数组中最小的元素应该位于该中间元素的后面。我们可以把第一个指针指向该中间元素，这样可以缩小寻找的范围。移动之后的第一个指针仍然位于前面的递增子数组之中。如果中间元素位于后面的递增子数组，那么它应该小于或者等于第二个指针指向的元素。此时该数组中最小的元素应该位于该中间元素的前面。

Step3.接下来我们再用更新之后的两个指针，重复做新一轮的查找。

按照上述的思路，第一个指针总是指向前面递增数组的元素，而第二个指针总是指向后面递增数组的元素。最终第一个指针将指向前面子数组的最后一个元素，而第二个指针会指向后面子数组的第一个元素。也就是它们最终会指向两个相邻的元素，而第二个指针指向的刚好是最小的元素。这就是循环结束的条件。

 

下面代码可以不用看，可以参考：https://blog.csdn.net/nsjlive/article/details/89827039   即可。

import java.util.ArrayList;
public class Solution {
 public int minNumberInRotateArray(int [] array) {
        if(array==null){
            return 0;
        }
        int low=0;
        int high=array.length-1;
        int indexMid=0;
        // 把indexMid初始化为low的原因：
        // 一旦发现数组中第一个数字小于最后一个数字，表明该数组是排序的
        // 就可以直接返回第一个数字了

        while(array[low]>=array[high]){
            // 如果low和high指向相邻的两个数，
            // 则low指向第一个递增子数组的最后一个数字，
            // high指向第二个子数组的第一个数字，也就是数组中的最小数字
            if(high-low==1){
                indexMid= high;
                break;
            }
            indexMid=low+(high+-low)/2;
            // 特殊情况：如果下标为low、high和indexMid指向的三个数字相等，则只能顺序查找
            if(array[low]==array[high]&& array[high]==array[indexMid]){
                return GetMinInOrder(array,low,high);
            }
            // 缩小查找范围
            //如果写成array[indexMid]>array[low]，就无法编译通过
            if(array[indexMid]>=array[low]){
                low=indexMid;
            }else if(array[indexMid]<=array[high]){
                high=indexMid;
            }

        }return array[indexMid];
    }

    public  int GetMinInOrder(int[] array, int low, int high){
        int result = array[low];
        for (int i = low + 1; i <= high; ++i)
        {
            if (result > array[i])
            {
                result = array[i];
            }
        }

        return result;

    }
}

注：上述代码过于复杂 

 indexMid=low+(high+-low)/2;
            // 特殊情况：如果下标为low、high和indexMid指向的三个数字相等，则只能顺序查找
            if(array[low]==array[high]&& array[high]==array[indexMid]){
                return GetMinInOrder(array,low,high);
            }

和

 public  int GetMinInOrder(int[] array, int low, int high){//

如果下标为low、high和indexMid指向的三个数字相等，则只能顺序查找

        int result = array[low];
        for (int i = low + 1; i <= high; ++i)
        {
            if (result > array[i])
            {
                result = array[i];
            }
        }

        return result;

    }

 都不是必须的，查找发现  array[low]==array[high]  && array[high]==array[indexMid] ，则可以判断最小数字在mid之前，可以把high=indexMid,再进行查找；

另外，如果下标为low、high和indexMid指向的三个数字相等，则只能顺序查找  

也不是必须的  ，依然可以用前面的方法查找。

所以代码可以简化为：

 public int minNumberInRotateArray(int [] array) {
        if(array==null){
            return 0;
        }
        int low=0;
        int high=array.length-1;
       
        int indexMid=0;
        
        while(array[low]>=array[high]){
            if(high-low==1){
                indexMid= high;
                break;
            }
            indexMid=low+(high-low)/2;
            
            if(array[indexMid]>array[low]){
                low=indexMid;
            }else  {
                high=indexMid;
            }

        }return array[indexMid];

补充：二分查找

    二分查找又称折半查找，它是一种效率较高的查找方法。mid=min+(max-min)/2 ,可以有效防止各种溢出。

    二分查找要求：线性表是有序表，即表中结点按关键字有序，并且要用向量作为表的存储结构。不妨设有序表是递增有序的。

/*折半查找  没有重复元素*/  
public int binarySearch(int[] nums, int target) {
    int low = 0, high = nums.length-1;
    while (low <= high) { 
        int mid = low + (high - low) / 2;
        if (nums[mid] < target) { low = mid + 1; }
        if (nums[mid] > target) { high = mid - 1; }
        if (nums[mid] == target) { return mid; }
    }
    return low;
}

有重复元素的情况 ：

//寻找元素第一次出现的位置。
public int firstOccurrence(int[] nums, int target) {
    int low = 0, high = nums.length-1;
    while (low <= high) {
        int mid = low + (high - low) / 2;
        if (nums[mid] < target) { low = mid + 1; }
        if (nums[mid] >= target) { high = mid - 1; }
    }
    return low;
}

 递归版本：

//寻找元素第一次出现的位置
public int firstOccurrenceRecur(int[] nums, int target, int low, int high) {
    if (low > high) { return low; }
    int mid = low + (high - low) / 2;
    if (nums[mid] < target) {
        return firstOccurrenceRecur(nums,target,mid + 1,high);
    } else {
        return firstOccurrenceRecur(nums,target,low,mid-1);
    }
}

参考：二分查找  https://www.zhihu.com/question/36132386 

https://blog.csdn.net/my_learning_road/article/details/79524362

二分查找  https://www.cnblogs.com/yedushusheng/p/5524166.html