二分查找练习

162. 寻找峰值

峰值元素是指其值严格大于左右相邻值的元素。

给你一个整数数组 nums，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回 任何一个峰值 所在位置即可。

你可以假设 nums[-1] = nums[n] = -∞ 。

你必须实现时间复杂度为 O(log n) 的算法来解决此问题。

示例 1：

输入：nums = [1,2,3,1]
输出：2
解释：3 是峰值元素，你的函数应该返回其索引 2。

示例 2：

输入：nums = [1,2,1,3,5,6,4]
输出：1 或 5 
解释：你的函数可以返回索引 1，其峰值元素为 2；
     或者返回索引 5， 其峰值元素为 6。

提示：

• 1 <= nums.length <= 1000
• -231 <= nums[i] <= 231 - 1
• 对于所有有效的 i 都有 nums[i] != nums[i + 1]

题目分析

根据我们前面学到的“红蓝染色法”，我们可以假设红色代表峰值左边的元素，也就是小于峰值的元素，而蓝色代表峰值以及峰值右边的元素，也就是大于等于峰值的元素，由于峰值一定在数组内，所以最右边的元素一定是蓝色，又由于“对于所有有效的 i 都有 nums[i] != nums[i + 1]”，所以我们只需要找到“即大于右边的元素又大于左边的元素”的元素的位置就可以了。

根据昨天的知识，我们便可以写出以下代码

代码

class Solution {
    public int findPeakElement(int[] nums) {
        int n = nums.length;
        int l = 0, r = n - 2;

        // [l, r]
        while(l <= r){
            int mid = l + (r - l) / 2;

            // 如果nums[mid] < nums[mid + 1]，则说明此时mid是红色的元素，而我们需要的是蓝色的元素，所以l = mid + 1;
            if(nums[mid] < nums[mid + 1]){
                l = mid + 1;
            }else {
                r = mid - 1;
            }
        }
        return l;
    }
}

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

已知一个长度为 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) 的算法解决此问题。

示例 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 次得到输入数组。

示例 3：

输入：nums = [11,13,15,17]
输出：11
解释：原数组为 [11,13,15,17] ，旋转 4 次得到输入数组。

提示：

• n == nums.length
• 1 <= n <= 5000
• -5000 <= nums[i] <= 5000
• nums 中的所有整数 互不相同
• nums 原来是一个升序排序的数组，并进行了 1 至 n 次旋转

题目分析

本题我们依然采用红蓝染色法，沿用上题思想，我们可以假设红色代表最小元素左边的元素，而蓝色代表最小元素以及最小元素右边的元素，由于最小元素一定在数组内，所以最右边的元素一定是蓝色，所以我们依然在$[0,n-2]$这个区间二分。

确定好了红蓝染色分别代表什么后，我们可以根据三种情况分析，由染色结果我们可以得到下述（情况一改为蓝全小于等于最后一个数）

确定好染色规则之后就可以写题啦~

代码

class Solution {
    public int findMin(int[] nums) {
        int n = nums.length;

        if(n == 1) return nums[0];
        if(nums[0] < nums[1] && nums[0] < nums[n - 1]) return nums[0];
        int l = 0, r = n - 2;

        while(l <= r){
            int mid = l + (r - l) / 2;
            if(nums[mid] > nums[n - 1]){
                l = mid + 1;
            }else {
                r = mid - 1;
            }
        }
        return nums[l];
    }
}

33. 搜索旋转排序数组

整数数组 nums 按升序排列，数组中的值 互不相同 。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。

给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。

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

示例 1：

输入：nums = [4,5,6,7,0,1,2], target = 0
输出：4

示例 2：

输入：nums = [4,5,6,7,0,1,2], target = 3
输出：-1

示例 3：

输入：nums = [1], target = 0
输出：-1

提示：

• 1 <= nums.length <= 5000
• -104 <= nums[i] <= 104
• nums 中的每个值都 独一无二
• 题目数据保证 nums 在预先未知的某个下标上进行了旋转
• -104 <= target <= 104

题目分析

本题我们需要找到target的位置，我们可以通过一定的逻辑判断来确定target在两段排序数组中属于哪一段，而后再进行二分，答案就十分明了了，而两段排序数组是以最小值为分界点。

那么本题可以利用上题我们得到的结论：只要一个数大于最后一个数，那么这个数就处在整个数组中较大的一部分，也就是上题中的红色，反之，如果一个数小于等于最后一个数，那么这个数就处在整个数组中较小的一部分，也就是上题中的蓝色。

而本题中我们可以假设等于target或在其右侧的数为蓝色，小于target或在其左侧的数为红色，如何确定呢？

其实很简单，上面我们提到了，只要一个数大于最后一个数，那么这个数就处在整个数组中较大的一部分，那么是蓝色的条件就是：

1. nums[mid]大于nums[end]（$mid$在较大的一段）
   1. nums[target]也大于nums[end]（$target$也在较大的一段），则需要nums[mid] >= nums[target]，$mid$才会是蓝色。
2. nums[mid]小于nums[end]（$mid$在较小的一段）
   1. nums[target]小于nums[end]（$target$也在较小的一段），且nums[mid] >= nums[target]，$mid$是蓝色
   2. nums[target]大于nums[end]（$target$也在较大的一段），则无论如何$mid$是蓝色。

那么捋清楚了这些，我们就可以写代码啦~

代码

class Solution {
    public int search(int[] nums, int target) {
        int n = nums.length;
        int l = 0, r = n - 1;

        // [l, r]
        while(l <= r){
            int mid = l + (r - l) / 2;
            if(is_blue(nums, target, mid)){
                r = mid - 1;
            }else {
                l = mid + 1;
            }
        }
        if( l < n && nums[l] == target) return l;
        return -1;
    }
    public boolean is_blue(int[] nums, int target, int i){
        int n = nums.length;
        int end = nums[n - 1];
        if(nums[i] > end){
            return target > end && nums[i] >= target;
        }else {
            return target > end || nums[i] >= target;
        }
        
    }
}