算法通关村——二分查找在拓展中的应用

1. 山脉数组的峰顶索引

山脉数组的峰顶索引
符合下列属性的数组 arr 称为 山脉数组 ：
arr.length >= 3
存在 i（0 < i < arr.length - 1）使得：
arr[0] < arr[1] < … arr[i-1] < arr[i]
arr[i] > arr[i+1] > … > arr[arr.length - 1]
给你由整数组成的山脉数组 arr ，返回满足 arr[0] < arr[1] < … arr[i - 1] < arr[i] > arr[i + 1] > … > arr[arr.length - 1] 的下标 i 。

你必须设计并实现时间复杂度为 O(log(n)) 的解决方案。

1.2. 遍历

从0到target这个元素之间都是递增关系，而target到最后是递减关系，只需要找到第一个元素比第二个元素大的时候，就是山峰

public int peakIndexInMountainArray(int[] arr) {
        for(int i=1;i<arr.length-1;i++){
            if(arr[i]>arr[i+1]){
                return i;
            }
        }
        return -1;
    }

但是这样是肯定不行的时间复杂度是O(n)不满足O(logn)的条件

2.2 二分法

题目明确指出需要使用logn的时间复杂度，二分是比较合适的。
首先根据二分法需要有三个状态的,大于，小于，等于。
而山峰数组的状态是从

1. low->mid都是递增 arr[mid] >arr[mid-1],arr[mid]
2. mid->hight都是递减 arr[mid] < arr[mid-1] arr[mid]>arr[mid+1]
3. l找到山顶元素

    public int peakIndexInMountainArray(int[] arr) {
        // 因为第一个元素必然是小于第二个元素的，所以可以从第二个元素开始
        int low = 1;
        // 同理最后一个元素是一定比倒数第二个元素小的
        int high = arr.length-2;
        while(low<=high){
            int mid = low+((high-low)>>1);
            // 处于递增情况
            if(arr[mid] > arr[mid-1] && arr[mid]< arr[mid+1]){
                low = mid+1;
                // 处于递减情况
            }else if(arr[mid] < arr[mid-1] && arr[mid]>arr[mid+1]){
                high=mid-1;
            }else{
                return mid;
            }
        }
        return -1;
    }

2. 寻找旋转排序数组中的最小值

寻找旋转排序数组中的最小值
已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：
若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]
若旋转 7 次，则可以得到 [0,1,2,4,5,6,7]
注意，数组 [a[0], a[1], a[2], …, a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], …, a[n-2]] 。

给你一个元素值 互不相同 的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。

你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。

2.1 二分

首先这个第一题的二分优点类似，只不过现在是最小元素的左边是大于它的，最小元素的右边也是大于它的。关键在于如何比较，之前的二分法都是由一定的比较对象，那么没有参照物，可以选择最右索引作为比较值，如果mid的值大于high的值，意味着目标值一定在mid-high中间，此时移动low指针，如果mid的值小于high，意味着处于递增状态，high的位置一定不可能最小，mid就赋值为high。

 public int findMin(int[] nums) {
        int low = 0;
        int high = nums.length-1;
        while(low<high){
            int mid = low+((high-low)>>1);
            if(nums[mid] < nums[high]){
                high=mid;
            }else{
                low = mid+1;
            }
        }
        return nums[low];
    }

3. 剑指 Offer 53 - II. 0～n-1中缺失的数字

剑指 Offer 53 - II. 0～n-1中缺失的数字
一个长度为n-1的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围0～n-1之内。在范围0～n-1内的n个数字中有且只有一个数字不在该数组中，请找出这个数字。

3.1 二分

由于所有的数都在0-n-1里面，只需要比较当前的mid的值的对应的nums[mid]是否一致，一样，那么就移动左指针，否则移动右指针，最后左指针停留的位置就是缺失的数字

 public int missingNumber(int[] nums) {
        int low = 0;
        int high = nums.length-1;
        while(low<=high){
            int mid = low+((high-low)>>1);
            if(nums[mid] == mid){
                low = mid+1;
            }else{
                high = mid-1;
            }
        }
        return low;
    }

4. LCR 072. x 的平方根

平方根
给定一个非负整数 x ，计算并返回 x 的平方根，即实现 int sqrt(int x) 函数。
正数的平方根有两个，只输出其中的正数平方根。
如果平方根不是整数，输出只保留整数的部分，小数部分将被舍去。

4.1 二分

假设输入4,正数平方根是2， low是1，high是4，那么中间值是2.5,取整是2，4/2是2符合
假设输入8,正数平方根是2， low是1，high是8，中间是4.5，取整4，8/4=2<4不满足，那么右指针移动high=3,中间值2, 8/2=4>2, 左指针移动2+1=3=右指针，终止退出，结果是2

 public int mySqrt(int x) {
        int low = 1; 
        int high =x;
        while(low<=high){
            int mid = low+((high-low)>>1);
            if(x/mid == mid){
                return mid;
            }else if(x/mid<mid){
                high=mid-1;
            }else{
                low=mid+1;
            }
        }
        return high;
    }

一样的题目
69. x 的平方根

总结

二分法的思路就是左右指针以及中间元素的的这种大小关系。如果提到了有序区间，那么可以考虑使用二分。