【剑指offer】06——旋转数组的最小数字

题目描述

  把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组 {3,4,5,1,2} 为 {1,2,3,4,5} 的一个旋转，该数组的最小值为1。

NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

一、二分查找

  二分查找的输入时一个有序的元素列表（必须有序），如果要查找的元素包含在列表中，二分查找返回其位置，否则返回null；

  假设有如下一个列表（数字1到100）：$[1,2,3,4,...,100]$，我随便想一个1到100的数字。你的目标是以 最少的次数 猜到这个数字。你每次猜测后，我会说小了、大了或对了。

• 方法一：如果你从1依次往上猜，最坏的情况（我想的是100），你就要猜100次；
• 方法二（二分查找）：你先猜50，如果我说小了，那么1-50这部分就不需要猜了，我想的数字一定在50-100中；接着你再猜75，大了，那么我想的数字就在50-75中，又少了一半，此时你只要猜 $lo{g}_{2}n$次；

使用二分查找时，你猜测的是中间的数字，从而每次都将余下的数字排除一半。

二、解题思路

  本题如果使用暴力法，那么从头到尾遍历数组一次，我们就能找到最小的元素，时间复杂度为 O(n)；实际上，旋转之后的数组可以划分为两个排序的子数组，而且前面子数组的元素都大于或者等于后面子数组，最小的元素刚好处于两个子数组的分界线。根据本题给出的数组一定程度上是排序的，因此我们可以用二分查找的方法来寻找这个最小的元素。

三、Java 代码

//暴力法（顺序查找）
import java.util.ArrayList;
public class Solution {
    public int minNumberInRotateArray(int [] array) {
    	//如果数组长度为0
        if(array.length == 0){
            return 0;
        }
        //从头到尾遍历数组
        for(int i = 0; i<array.length - 1; i++){
            if(array[i] > array[i+1]){
                return array[i+1];
            }
        }
        return array[0];
    }
}


//二分法
import java.util.ArrayList;
public class Solution {
    public int minNumberInRotateArray(int [] array) {
        //如果数组为空或者长度为0，则返回0
        if(array == null || array.length == 0){
            return 0;
        }
        int left = 0;  //左索引
        int right = array.length - 1;  //右索引
        int mid = 0;  //一开始中间元素的初始化为索引0
        
        //特殊情况1
        if(array[left] < array[right]){
            return array[left];
        }
        
        while(array[left] >= array[right]){
            //R - L = 1时最小元素就是M
            if(right - left == 1){
                mid = right;
                break;
            }
            mid = (right-left) / 2 + left;  //M计算公式
            //特殊情况2,需要调用顺序查找
            if(array[left] == array[mid] && array[right] == array[mid]){
                return MinInOrder(array, left , right);
            }
            //如果L < M，此时最小值在M后面，将L移到M
            if(array[left] <= array[mid]){
                left = mid;
            }else if(array[right] >= array[mid]){  //L > M，此时最小值在M前面或本身，将R移到M
                right = mid;
            }
        }
        return array[mid];  //返回M
    }
    public int MinInOrder(int[] array, int left, int right){
        int result = array[left];
        for(int i = left + 1; i < right; i++){
            if(array[i] < result){
                result = array[i];
            }
        }
        return result;
    }
}

四、C++ 代码

class Solution {
public:
    int minNumberInRotateArray(vector<int> array) {
        int size = array.size(); //数组长度
        if(size == 0){
            return 0; //数组长度为0，返回0
        }
        int left = 0; //左指针
        int right = size - 1; //右指针
        int mid = 0;
        while(array[left] >= array[right]){
            //R - L = 1时最小元素就是M
            if(right - left == 1){
                mid = right;
                break;
            }
            mid = (right-left) / 2 + left;  //M计算公式
            //特殊情况2,需要调用顺序查找
            if(array[left] == array[mid] && array[right] == array[mid]){
                return MinInOrder(array, left , right);
            }
            //如果L < M，此时最小值在M后面，将L移到M
            if(array[left] <= array[mid]){
                left = mid;
            }else if(array[right] >= array[mid]){  //L > M，此时最小值在M前面或本身，将R移到M
                right = mid;
            }
        }
        return array[mid];  //返回M
    }
    
    int MinInOrder(vector<int> &array, int left, int right){
        int result = array[left];
        for(int i = left + 1; i < right; i++){
            if(array[i] < result){
                result = array[i];
            }
        }
        return result;
    }
};

五、Python3 代码

# -*- coding:utf-8 -*-
class Solution:
    def minNumberInRotateArray(self, array):
        # write code here
        if len(array) == 0:
            return 0
        left = 0
        right = len(array) - 1
        mid = 0
        while array[left] >= array[right]:
            # R - L = 1时最小元素就是M
            if right - left == 1:
                mid = right
                break
            mid = (right-left) / 2 + left  # M计算公式
            # 特殊情况2,需要调用顺序查找
            if array[left] == array[mid] == array[right]:
                return MinInOrder(array, left , right)
            # 如果L < M，此时最小值在M后面，将L移到M
            if array[left] <= array[mid]:
                left = mid
            elif array[right] >= array[mid]:  # L > M，此时最小值在M前面或本身，将R移到M
                right = mid
        return array[mid]
    
    def MinInOrder(self, array, left, right):
        result = array[left]
        for i in range(left+1, right):
            if array[i] < result:
                result = array[i]
        return result