算法通关村——基于二分查找的拓展问题

基于二分查找的拓展问题

1、山脉数组的峰顶索引

​ LeetCode852. 符合下列属性的数组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[i + 2] > … > arr[arr.length - 1]的下标i。

​ 简单来说就算数组中有个位置 i ，在 i 之前的 0 - i 之间是递增的，从 i + 1到数组的最后是递减的，要找出这个i，如图下所示：

​

​ 图中5对应的索引就是题目需要的。

​ 二分查找可以运用到这个题上来。

​ 对于二分的某一个位置mid，mid的位置可能有3种情况：

​ ① mid在上升阶段，满足arr[mid] > arr[mid - 1] && arr[mid] < arr[mid + 1]

​ ② mid在顶峰的时候，满足arr[mid] > arr[mid - 1] && arr[mid] > arr[mid + 1]

​ ③ mid在下降阶段，满足arr[mid] < arr[mid - 1] && arr[mid] > arr[mid + 1]

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

​ 代码如下：

public int peakIndexInMountainArray(int[] arr) {
    if (arr.length == 3) {
        return 1;
    }
    int left = 0;
    int right = arr.length - 1;
    while (left < right) {
        int mid = left + ((right - high) >> 1);
        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]) {
            return mid;
        }
        if (arr[mid] < arr[mid - 1] && arr[mid] > arr[mid + 1]) {
            right = mid - 1;
        }
    }
    return left;
}

2、旋转数字的最小数字

​ LeetCode153. 已知一个长度为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 = [4, 5, 1, 2, 3]

  输出：1

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

​ 以下是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];
}

3、总结

high = pivot;
} else {
low = pivot + 1;
}
}
return nums[low];
}

## 3、总结

​	凡是在有序区间查找的场景，都可以用二分查找来优化速度。如果有序区间是变化的，那就每次都针对这个变化的区间进行二分查找。