旋转数组的最小值

package offer008;

import java.util.Scanner;

/** 
 * @Title: Main.java
 * @Package: offer008
 * @Description 旋转数组的最小数字
 * @author Han
 * @date 2016-4-18 上午10:39:35 
 * @version V1.0
 */ 
      
public class Main {
    
    public static void main(String[] args) {
        
        Scanner scanner = new Scanner(System.in);
        int[] arr = null;
        int count = 0;
        
        while(scanner.hasNext()){
            
            //输入数组的大小
            count = scanner.nextInt();
            arr = new int[count];
            
            //输入数组
            for(int i = 0; i < count; i++){
                
                arr[i] = scanner.nextInt();
            }
            System.out.println(min(arr));
        }
    }
    
     
    /** 
     * @Description 得到旋转数组中的最小值
     * @author Han
     * @param arr
     * @return  min
     */
          
    private static int min(int[] arr){
        
        //判断数组是否为空,长度是否为0
        if(arr == null || arr.length == 0){
            
            throw new RuntimeException("Error Input");
        }
        
        //头下标
        int startIndex = 0;
        //尾下标
        int endIndex = arr.length - 1;
        //中间下标
        int middleIndex = 0;
        
        //如果数组中的第一个值小于了最后一个值，则表明该数组为一个递增数组，直接输出第一个元素即可
        while(arr[startIndex] >= arr[endIndex]){

            //若该startIndex和endIndex相邻成立则表示endIndex指向的数字为最小值
            if(endIndex - startIndex == 1){
                
                startIndex = endIndex;
                break;
            }
            
            middleIndex = (startIndex + endIndex) / 2;
            
            //如果三个值相等，类似于1 0 1 1 1 1，则需要需要通过顺序查找出最小值
            if(arr[middleIndex] == arr[startIndex] && arr[middleIndex] == arr[endIndex]){
                
                return minByOrder(arr, startIndex, endIndex);
            }
            
            //若中间值大于startIndex指向的值，则移动startIndex到中间值
            if(arr[middleIndex] >= arr[startIndex]){
                
                startIndex = middleIndex;
            }else if(arr[middleIndex] <= arr[endIndex]){
                
                endIndex = middleIndex;
            }
        }
        
        return arr[startIndex];
    }

     
    /** 
     * @Description 顺序查找出最小值
     * @author Han
     * @param arr
     * @param startIndex
     * @param endIndex
     * @return  
     */
          
    private static int minByOrder(int[] arr, int startIndex, int endIndex) {

        int min = arr[startIndex];
        
        for(int i = startIndex + 1; i <= endIndex; i++){
            
            if(arr[i] < min){
                
                min = arr[i];
            }
        }
        
        return min;
    }
}