旋转数组的最小数字

题目描述

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

思路

我的初始想法：从头开始遍历元素，相邻两个元素应该是递增顺序，如果遇到第一个不递增的，则这个数即为最小值。

边界分析

空数组，特殊情况：数组一开始就全为递增，数组中有元素相等（未想到）

复杂度

时间复杂度：O(n) 空间复杂度:O(1)

代码实现

import java.util.ArrayList;
public class Solution {
    public int minNumberInRotateArray(int [] array) {
        int length = array.length-1;
        int index = 0;
        for(int i=0;i<length;i++){
            if(array[i]<=array[i+1]){//第一次提交失败，看了测试用例才知道可能会存在两个数字相等的情况
                continue;
            }
            index = i+1;
            break;
        }
        return array[index];
    }
}

优化

剑指offer提供的思路：二分查找

思路

由于是两个递增的子序列，所以会存在边界元素。设置头指针和尾指针分别指向数组的第一和最后元素，通过二分查找的方式不断缩小查找范围，直到定位到这个边界元素，循环终止的条件是：头指针和尾指针之间相差1.

边界

空数组（测试用例不包含，若为空返回0），有元素相等（比较时注意）

实现

我的实现方式：通过递归的方法，不断缩小搜寻的范围，直到定位出最小元素

import java.util.ArrayList;
public class Solution {
    public int getIndex(int[] array,int firstIndex,int lastIndex){
        if(firstIndex == lastIndex-1){
           return array[lastIndex];
        }
        int mid = (firstIndex+lastIndex)/2;
        if(array[firstIndex]>array[mid]){
           return getIndex(array,firstIndex,mid);
        }else if(array[mid]>array[lastIndex]){
           return getIndex(array,mid,lastIndex);
        }else{
           return array[firstIndex];
        }
    }
    public int minNumberInRotateArray(int [] array) {
        if(array == null)
            return 0;
        if(array.length == 1)
            return array[0];
        int first = 0;
        int last = array.length - 1;
        return getIndex(array,first,last);     
    }
}

别人提供的解题方式：采用非递归的方式，用while循环，也是变换头尾指针实现，循环的终止条件是last指针=fist+1

import java.util.ArrayList;
public class Solution {
    public int minNumberInRotateArray(int [] array) {
        if(array == null)
            return 0;
        if(array.length == 1)
            return array[0];
        int firstIndex = 0;
        int lastIndex = array.length - 1;
        while(lastIndex - 1 > firstIndex){
            int mid = (firstIndex+lastIndex)/2;
            if(array[firstIndex]>array[mid]){
               lastIndex = mid;
            }else if(array[mid]>array[lastIndex]){
               firstIndex = mid;
            }else{
               return array[firstIndex];
            }    
        }
        return array[lastIndex];
        
    }
}

复杂度

时间：O(logN) 空间O(1)

总结

看了剑指offer的分析后，发现遗漏了很重要的东西：

如果头指针和尾指针指向的元素相等的时候该怎么办，之前我的想法太片面了，认为头指针和尾指针相同的时候数组的所有元素相等。其实不然，如果所有元素相等就和题设旋转数组的特性不符合了，即使fist=mid=last，数组也不可能完全相等。根据旋转数组的特性，即使旋转的元素为0个，也必须存在一个递增序列。所以根本不存在所有元素相等的情况。因此，上述代码是不完全正确的。

书上这样说：如果存在{1,0,1,1,1,1,1}这样的数组，此时二分查找法不适应的，只能通过顺序查找来实现。

改进的思路：

import java.util.ArrayList;
public class Solution {
    public int minNumberInRotateArray(int [] array) {
        if(array == null)
            return 0;
        if(array.length == 1)
            return array[0];
        int firstIndex = 0;
        int lastIndex = array.length - 1;
        while(lastIndex - 1 > firstIndex){
            int mid = (firstIndex+lastIndex)/2;
            if(array[firstIndex]>array[mid]){
               lastIndex = mid;
            }else if(array[mid]>array[lastIndex]){
               firstIndex = mid;
            }else if(array[firstIndex] == array[lastIndex] && array[mid] == array[lastIndex]){
               //顺序查找
                for(int i=firstIndex;i<lastIndex;i++){
                    if(array[firstIndex]<= array[firstIndex+1]){
                        continue;
                    }
                    return array[firstIndex+1];
                }
            }else{
               return array[firstIndex];
            }    
        }
        return array[lastIndex];
        
    }
}