剑指offer面试题11(java版):旋转数组的最小数字

welcome to my blog

剑指offer面试题11(java版):旋转数组的最小数字

题目描述

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

第四次做; 核心: 为什么要和右部分比? 因为目标值处于右部分; 这道题就是LeetCode 154题; 之所以不能让mid跟左边界比较的原因, 针对案例{10,1,10,10,10}, 如果mid和左边界比较, 那么left++后, left指向元素1, 下一轮循环时mid会认为自己在左部分, 而实际上mid此时已经在右部分了, 所以mid会错误把自己往右部分移动; 针对案例{10,10,10,1,10}, 如果mid和右边界比较, 那么right–后, right指向元素1, 下一轮循环时mid会认为自己在左部分, 这是正确的!

双指针; 左指针和右指针最后指向同一个元素, 也就是指向旋转数组的最小数字
核心: 和右边界比较; 最终要定位的元素: 右部分的第一个
要清楚, 左部分整体大于等于右部分
核心: 为什么mid和right比? 因为目标在右部分, 所以和处于右部分中的right比

public class Solution {
    public int minNumberInRotateArray(int [] array) {
        if(array==null || array.length==0)
            return 0;
        int n = array.length;
        //不能取等于, 因为:{10,1,10,10,10};   {10,10,10,1,10}
        if(array[0] < array[n-1])
            return array[0];
        //双指针; 左指针和右指针最后指向同一个元素, 也就是指向旋转数组的最小数字
        //核心: 和右边界比较; 最终要定位的元素: 右部分的第一个
        //要清楚, 左部分整体大于等于右部分
        //核心: 为什么mid和right比? 因为目标在右部分, 所以和处于右部分中的right比
        int left=0, right=n-1, mid;
        while(left < right){
            mid = left + ((right-left)>>1);
            //mid在左部分
            if(array[mid] > array[right])
                left = mid+1;
            //mid在右部分
            else if(array[mid] < array[right])
                right = mid;
            //不知道在哪个部分
            else{
                right--;
            }
        }
        return array[left];
    }
}

第三次做, 二分查找, 二分到死; 这次做错了! 这次做错了! 这次做错了! mid得和right比, 下面的方法不能通过案例{10,1,10,10,10}

/*
使用双指针, left位于前部末尾, right位于后部开头
使用二分法更新指针
二分到死
*/
public class Solution {
    public int minNumberInRotateArray(int [] array) {
        if(array==null || array.length==0)
            return 0;
        
        int left=0, right = array.length-1 , mid;
        while(left<=right){
            mid = left + ((right-left)>>1);
            //mid在左部分
            if(array[mid] > array[left])
                left = mid;
            //mid在右部分
            else if(array[mid] < array[left])
                right = mid;
            //不知道mid在哪部分, 左边界缩减1
            else
                left++;
        }
        return array[right];
    }
}

第二次做

• 四处需要注意:
• 左右指针的含义很关键
• 只需要将arr[mid]和arr[right]进行比较，没用到arr[left]； 所以这道题不同于同时与两个数比较的
• 循环条件很关键
• 处理arr[mid]==arr[right]时很关键

public class Solution {
    public int minNumberInRotateArray(int [] array) {
        if(array.length==0) return 0;
        int left=0, right=array.length-1, mid;
        //还是用剑指上的思路更好一些,起初left指向左部分, right指向右部分
        //二分到最后: left最终指向左部分的末尾,right最终指向右部分的开头
        //二分到死的结果是left与right相邻,也就是left+1 == right
        //所以达不到这个条件时要继续二分
        while(left + 1 < right){ 
            mid = left + ((right-left)>>1);
            //理解各个分支的关键在于时刻明确:left最终指向左部分, right最终指向右部分
            if(array[mid] < array[right]) 
                right = mid;
            else if(array[mid] > array[right]) 
                left = mid;
            else{ //arr[mid] == arr[right]  相等时不知道最小值在左部分还是右部分
                right = right - 1;
            }
        }
        return array[right]; 
    }
}

第二次做

import java.util.ArrayList;
public class Solution {
    /*
    这道题让我想起了之前的两道题, 同一个数会和两个数进行比较, 比较后会出现多种情况
    比如,a分别和b,c进行比较, 结果可能是a>b,a<b;   a>c,a<c  此处暂未考虑等于
    如何巧妙使用if, else if, else是关键
    
    经分析知,如果数组分为左右两部分, 且左右两部分都是非递减的. 那么最小值大概率在右边这部分; 除非数组没有旋转,或者说整体一起旋转了
    此时主要考虑arr[mid]和arr[right]的大小关系
    
    使用二分法的思想,但不像平常遇到的二分法的题
    arr[mid] > arr[left], 说明arr[mid]在其中一个递增子序列中, left = mid + 1
    arr[mid] < arr[right], 说明arr[mid]在另一个递增子序列中, right = mid - 1
    
    arr[mid] < arr[left], right = mid - 1
    arr[mid] > arr[right], left = mid + 1
    
    arr[mid] == arr[left] && arr[mid] == arr[right]
    */
    public int minNumberInRotateArray(int [] array) {
        if(array.length==0) return 0;
        int left=0, right=array.length-1, mid;
        while(left<=right){
            mid = left + ((right-left)>>1);
            //各个条件下的语句都表明我们希望在右部分进行探索
            if(array[mid] < array[right]) //arr[mid]在右部分,且mid可能就是最终的结果,但还是需要以mid为新right, 二分到死
                right = mid;
            else if(array[mid] > array[right]) //arr[mid]在左部分
                left = mid + 1;
            else{ //arr[mid] == arr[right]  相等时不知道最小值在左部分还是右部分
                right = right - 1; //这一句能让我们跳出循环
            }
        }
        return array[left]; //最终要返回array[left]而不是array[right]
    }
}

思路

• 见注释

复杂度

• 时间复杂度: 因为采用的是二分查找,所以时间复杂度是O(logn)
• 空间复杂度: O(1)

import java.util.ArrayList;
public class Solution {
    public int minNumberInRotateArray(int [] array) {
        // 健壮性判断
        if(array == null)
            return 0; //题目要求
        // 正式执行
        /*
        准备: 使用二分查找的思路, 设置两个指针p1,p2分别指向数组的起始和末尾, 还有一个mid指针指向p1,p2的中间位置
        1. p1永远指向第一个递增子序列中的元素, p2永远指向第二个递增子序列中的元素, 二分查找到最后:p1指向最大值, p2指向最小值
        2. 如果arr[mid] >= arr[p1] 说明mid在第一个递增子序列中, 令p1 = mid
           如果arr[mid] <= arr[p2] 说明mid在第二个递增子序列中, 令p2 = mid
           特例1:旋转了0个元素到末尾,此时arr[0]就是最小值
           特例2:arr[p1] == arr[p2] == arr[mid], 此时无法判断最小值位于哪个递增子序列中,只能用顺序查找
        */
        int p1 = 0;
        int p2 = array.length - 1;
        int mid = 0;
        // 特例1,同时也能解决数组只有1个元素的情况
        if(array[0]< array[array.length-1]) // 判断条件不能是<=
            return array[0];
        // 普通情况
        while(array[p1] >= array[p2]){ //while条件写什么好?
            if(p2-p1==1){
                mid = p2;
                break;
            }
            mid = (p1 + p2) / 2;
            if(array[mid] >= array[p1])
                p1 = mid;
            if(array[mid] <= array[p2])
                p2 = mid;
            // 特例2
            if(array[p1] == array[p2] && array[p1] == array[mid])
               return findByOrder(array, p1, p2);
        }
        return array[mid];
    }
    public int findByOrder(int[] array, int p1, int p2){
        int min = array[p1];
        for(int i=p1; i<=p2; i++){
            if(min > array[i])
                min = array[i];
        }
        return min;
    }
}

看看队列的toString()是什么样子

进队顺序为1,2,3,4,5

import java.util.ArrayList;
public class Solution {
    public int minNumberInRotateArray(int [] array) {
        if(array.length==0) return 0;
        //二分法去找最小值
        //最小值的特点：小于左边，小于等于右边
        //将array[mid]和它相邻的两个元素作比较没有用， 比较结果没有指导意义
        int left=0, right=array.length-1, mid;
        while(left <= right){
            mid = left+((right-left)>>1);
            if(array[mid] >= array[mid-1])
                left = mid + 1; //越界判断怎么加？
            else if(array[mid] > array[mid+1])
                left = mid + 1;
            else
                return array[mid];
        }
        return array[0];
        
    }
}