算法通关村 | 二分查找与搜索树高频问题

山脉数组的峰顶索引

LeetCode852.这个题的要求有点啰嗦，核心意思就是在数组中的某位位置i开始，从0到i是递增的，从i+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 。
这个题其实就是前面找最小值的相关过程而已，最简单的方式是对数组进行一次遍历。
当我们遍历到下标i时，如果有arr[i-1]<arr[i]>arr[i+1],那么i就是我们需要找出的下标。
其实还可以更简单一些，因为是从左开始找的，开始的时候必然是arr[i-1]<a[i],所以只要找到第一个arr[i]>arr[i+1]的位置即可。代码就是：

示例 1：
输入：arr = [0,1,0]
输出：1

示例 2：
输入：arr = [0,2,1,0]
输出：1

示例 3：
输入：arr = [0,10,5,2]
输出：1

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

这个题能否使用二分来优化一下呢？当然可以。
对于二分的某一个位置 mid，mid 可能的位置有3种情况:

• mid在上升阶段的时候，满足 arr[mid] > a[mid-1] && arr[mid] > arr[mid+1]
• mid在顶峰的时候，满足arr[i] > a[i-1] && arr[i] > arr[i+1]
• mid在下降阶段，满足arr[mid] > a[mid-1] && arr[mid] < arr[mid+1]

因此我们根据 mid 当前所在的位置，调整二分的左右指针，就能找到顶峰。

public int peakIndexInMountainArray(int[] arr) {
    if (arr.length== 3)
        return 1;

    int left = 1, right = arr.length - 2;
    while(left < right) {
        int mid =left+ ((right - left)>>1);
        if (arr[mid] > arr[mid - 1] && arr[mid] > arr[mid + 1])
            return mid;
        if (arr[mid] < arr[mid + 1] && arr[mid] > arr[mid - 1])
            left = mid + 1;
        if (arr[mid] > arr[mid + 1] && arr[mid] < arr[mid - 1])
            right = mid - 1;
    }
    return left;
}

旋转数字的最小数字

我们说刷算法要按照专题来刷，这样才能看清很多题目的内在关系，二分查找也是如此，很多题目看似与二分无关，但是就是在考察二分查找，我们一起看一下。
LeetCode153 已知一个长度为 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]] 。

示例1：
输入：nums = [3,4,5,1,2]
输出：1
解释：原数组为 [1,2,3,4,5] ，旋转 3 次得到输入数组。

示例2：
输入：nums = [4,5,6,7,0,1,2]
输出：0
解释：原数组为 [0,1,2,4,5,6,7] ，旋转 4 次得到输入数组。

使用顺序遍历

class Solution {
    public int findMin(int[] nums) {
        int len = nums.length;
        if(len == 1 )
            return nums[0];
        int min = nums[0];
        for(int i = 1; i < len; i++){
            if(nums[i] < nums[i - 1]){
                min = nums[i];
                break;
            }
        }
        return min;
    }
}

本部分都摘自LeetCode一个不包含重复元素的升序数组在经过旋转之后，可以得到下面可视化的折线图：

其中横轴表示数组元素的下标，纵轴表示数组元素的值。图中标出了最小值的位置，是我们需要查找的目标。

我们考虑数组中的最后一个元素 x：在最小值右侧的元素（不包括最后一个元素本身），它们的值一定都严格小于 x；而在最小值左侧的元素，它们的值一定都严格大于 x。因此，我们可以根据这一条性质，通过二分查找的方法找出最小值。

在二分查找的每一步中，左边界为 low，右边界为 high，区间的中点为 pivot，最小值就在该区间内。我们将中轴元素 nums[pivot] 与右边界元素 nums[high] 进行比较，可能会有以下的三种情况：

**第一种情况是nums[pivot] < nums[high]。**如下图所示，这说明nums[pivot] 是最小值右侧的元素，因此我们可以忽略二分查找区间的右半部分。

**第二种情况是 nums[pivot] > nums[high]。**如下图所示，这说明nums[pivot] 是最小值左侧的元素，因此我们可以忽略二分查找区间的左半部分。

由于数组不包含重复元素，并且只要当前的区间长度不为 1，pivot 就不会与high 重合；而如果当前的区间长度为 1，这说明我们已经可以结束二分查找了。因此不会存在 nums[pivot]=nums[high] 的情况。

当二分查找结束时，我们就得到了最小值所在的位置。

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

这里你是否注意到high = pivot;而不是我们习惯的high = pivot-1呢？这是为了防止遗漏元素，例如[3,1,2]，执行的时候nums[pivot]=1，小于nums[high]=2，此时如果high=pivot-1，则直接变成了0。所以对于这种边界情况，很难解释清楚，最好的策略就是多写几种场景测试一下看看。这也是二分查找比较烦的情况，一般来说解释比较困难，也不容易理解清楚，所以写几个典型的例子试一下，面试的时候大部分case能过就能通过。
我们可以再拓展一下，如果在上面的基础上存在重复元素会怎么样呢？感兴趣的同学可以研究一下LeetCode154这道题。

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

示例 1：
输入：nums = [1,3,5]
输出：1

示例 2：
输入：nums = [2,2,2,0,1]
输出：0

遍历的方法还是可以使用的。

二分法

第一种情况是 nums[pivot] < nums[high]。如下图所示，这说明 nums[pivot] 是最小值右侧的元素，因此我们可以忽略二分查找区间的右半部分。

第二种情况是 nums[pivot] > nums[high]。如下图所示，这说明 nums[pivot] 是最小值左侧的元素，因此我们可以忽略二分查找区间的左半部分。

第三种情况是 nums[pivot]==nums[high]]。如下图所示，由于重复元素的存在，我们并不能确定 nums[pivot] 究竟在最小值的左侧还是右侧，因此我们不能莽撞地略某一部分的元素。我们唯一可以知道的是，由于它们的值相同，所以无论 nums[high] 是不是最小值，都有一个它的「替代品」nums[pivot]，因此我们可以忽略二分查找区间的右端点。

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