旋转数组的最小元素

旋转数组的最小元素

题目描述

• 输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
• NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

1. 数组的旋转 ：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
   例：[1,2,3,4,5] → [3,4,5,1,2]
2. 非递减排序的数组 ：未必是严格递增，可能有重复的值。
   例：[1,2,2,4,5,5,5,7]

方法分析

• 最简单低效的做法：遍历整个数组，找到最小元素。

import java.util.ArrayList;
public class Solution {
    public int minNumberInRotateArray(int [] array) {
        int len = array.length;
        if(len == 0){
            return 0;
        }
        else{
        int min = array[0];
            for(int i = 0; i < len; i++){
                if(array[i] < min){
                    min = array[i];
                }
            }
        return min;
        }
    }
}

• 对上述方法稍微优化一下

import java.util.ArrayList;
public class Solution {
   public int minNumberInRotateArray(int[] array) {
   		int len = array.length;
		if (len == 0)
			return 0;
		for (int i = 0; i < len - 1; i++) {
			if (array[i] > array[i + 1])
				return array[i + 1];
		}
		return array[0];
	} 
}

• 二分法
  采用二分法解答这个问题，需要考虑三种情况：
   1.array[mid] > array[right]:
      比如[3,4,5,1,2]，此时最小元素一定在mid的右边。
   2.array[mid] == array[right]:
      解决特殊情况，比如 [2,1,2,2,2] ，此时无法判断最小元素在mid哪边，这时只好挨个试。
   3.array[mid] < array[right]:
      比如[5,1,2,3,4]，此时最小数字可能是array[mid]或者在mid的左边。
  Note：如果查询范围只剩最后两个数，根据定义mid = left + (right - left) / 2，那么mid 一定会指向前面那个元素。
      比如 array = [1,2]
      此时，array[left] = 1 ;array[mid] = 1 ; array[right] = 2 ;
      如果right = mid - 1，就会报错， 此处应该改为right = mid。

import java.util.ArrayList;
public class Solution {
    public int minNumberInRotateArray(int [] array) {
        int len = array.length;
        if(len == 0){
            return 0;
        }
        else{
            int left = 0;
            int right = len - 1;
            while(left < right){
                int mid = left + (right - left) / 2;
                //如果array[mid]>array[right]，则最小值一定在右半边
                if(array[mid] > array[right]){
                    left = mid + 1;
                }
                //解决特殊情况，如：[2,1,2,2,2],只能逐个比较
                else if(array[mid] == array[right]){
                    right = right - 1;
                }
                //array[mid]<array[right]，最小值一定是array[mid]或在左半边
                else{
                    right = mid;
                }
            }
        return array[left];
        }
    }
}

• 改进的二分法

import java.util.ArrayList;
public class Solution {
    public int minNumberInRotateArray(int [] array) {
        int len = array.length;
        if(len == 0){
            return 0;
        }
        else{
            int left = 0;
            int right = len - 1;
            while(left < right){
                int mid = left + (right - left) / 2;
                //如果array[mid]>array[right]，则最小值一定在右半边
                if(array[mid] > array[right]){
                    //如果array[mid]>array[mid+1]，则最小值为array[mid+1]
                    if(array[mid]>array[mid + 1]){
                        return array[mid + 1];
                    }
                    //否则在右半边
                    else{
                        left = mid + 1;
                    }
                }
                //解决特殊情况，如：[2,1,2,2,2],只能逐个比较
                else if(array[mid] == array[right]){
                    right = right - 1;
                }
                //array[mid]<array[right]，最小值一定是array[mid]或在左半边
                else{
                    //如果array[mid-1]>array[mid]，则最小值为array[mid]
                    if(array[mid - 1]>array[mid]){
                        return array[mid];
                    }
                    //否则在左半边
                    else{
                        right = mid;
                    }
                }
            }
        return array[left];
        }
    }
}