专题三：二分法问题整理(Leetcode例题及解题思路)

1.LeetCode69.x 的平方根

题目：
　　实现 int sqrt(int x) 函数。
　　计算并返回 x 的平方根，其中 x 是非负整数。
　　由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。
示例 1:
　　输入: 4
　　输出: 2
示例 2:
　　输入: 8
　　输出: 2
　　说明: 8 的平方根是 2.82842…,
　　　由于返回类型是整数，小数部分将被舍去。
解题思路：
　　当ｘ＞＝２，他的整数平方根一定小于ｘ／２且大于０，即０＜ａ＜ｘ／２。由于ａ一定是整数，此问题可以转化为有序整数集中寻找一个特定值，因此可以使用二分查找。
　

class Solution {
    public int mySqrt(int x) {
        if(x <= 1){
            return x;
        }
        int left = 0;
        int right = x / 2;
        long x_pre = 0L;
        while(left <= right){
            int mid = left + (right - left) / 2;
            x_pre = (long) mid * mid;
            if(x_pre > x){
                right = mid - 1;
            }else if(x_pre < x){
                left = mid + 1;
            }else{
                return mid;
            }
        }
        return right;
    }
}

2.LeetCode744. 寻找比目标字母大的最小字母

题目：
　　给定一个只包含小写字母的有序数组letters 和一个目标字母 target，寻找有序数组里面比目标字母大的最小字母。
　　在比较时，数组里字母的是循环有序的。举个例子：
　　如果目标字母 target = ‘z’ 并且有序数组为 letters = [‘a’, ‘b’]，则答案返回 ‘a’。
　　如果目标字母 target = ‘n’ 并且有序数组为 letters = [‘m’, ‘z’, ‘c’, ‘f’, ‘j’] ，则答案返回 ‘z’。
示例：
　　输入:
　　letters = [“c”, “f”, “j”]
　　target = “a”
　　输出:
　　 “c”
　　
　　输入:
　　letters = [“c”, “f”, “j”]
　　target = “c”
　　输出:
　　“f”

输入:
　　letters = [“c”, “f”, “j”]
　　target = “d”
　　输出:
　　 “f”
提示：
　　letters长度范围在[2, 10000]区间内。
　　letters 仅由小写字母组成，最少包含两个不同的字母。
　　目标字母target 是一个小写字母。
解题思路：
　　二分法

class Solution {
    public char nextGreatestLetter(char[] letters, char target) {
        int left = 0;
        int right = letters.length - 1;
        while(left <= right){
            int mid = left + (right - left) / 2;
            if(letters[mid] <= target){
                left = mid + 1;
            }else{
                right = mid - 1;
            }
        }
        return letters.length > left ? letters[left] : letters[0];
    }
}

３.LeetCode540. 有序数组中的单一元素

题目：
　　给定一个只包含整数的有序数组，每个元素都会出现两次，唯有一个数只会出现一次，找出这个数。
示例 1:
　　输入: [1,1,2,3,3,4,4,8,8]
　　输出: 2
示例 2:
　　输入: [3,3,7,7,10,11,11]
　　输出: 10
注意: 您的方案应该在 O(log n)时间复杂度和 O(1)空间复杂度中运行。
解题思路：
　　我们的数组个数始终是奇数，因为有一个元素出现一次，其余元素出现两次。
　　
　　下面是当我们从中心移除一对元素时发生的情况。将剩下左子数组和右子数组。
　　
　　与原数组一样，包含单个元素的子数组元素个数必为奇数，不包含单个元素的子数组必为偶数。 因此，当原数组移除一对元素后，然后计算出哪一侧的子数组元素个数是奇数，这样我们就能够知道下一步应该在哪一侧进行搜索。
　　算法：
　　我们首先将 left和 right 指向数组首尾两个元素。然后进行二分搜索将数组搜索空间减半，直到找到单一元素或者仅剩一个元素为止。当搜索空间只剩一个元素，则该元素就是单个元素。
　　在每个循环迭代中，我们确定 mid，变量 (right - mid) % 2 == 0。 通过查看中间元素同一元素为哪一个（左侧子数组中的最后一个元素或右侧子数组中的第一个元素），我们可以通过变量 (right - mid) % 2 == 0 确定现在哪一侧元素个数为奇数，并更新 left 和 right。
　　最难的部分是根据 mid 和 (right - mid) % 2 == 0的值正确更新 left 和 right。我们通过下图来帮助我们理解。
　　例子 1：中间元素的同一元素在右边，且被 mid 分成两半的数组为偶数。
　　我们将右子数组的第一个元素移除后，则右子数组元素个数变成奇数，我们应将 left设置为 mid + 2。

　　例子 2：中间元素的同一元素在右边，且被 mid 分成两半的数组为奇数。
　　我们将右子数组的第一个元素移除后，则右子数组的元素个数变为偶数，我们应将 right设置为 mid - 1。

　　例子 3：中间元素的同一元素在左边，且被 mid 分成两半的数组为偶数。
　　我们将左子数组的最后一个元素移除后，则左子数组的元素个数变为奇数，我们应将 right设置为 mid - 2。
　　
　　例子 4：中间元素的同一元素在左边，且被 mid 分成两半的数组为奇数。
　　我们将左子数组的最后一个元素移除后，则左子数组的元素个数变为偶数，我们应将 left设置为 mid + 1。
　　
　　我们可以仅对偶数索引进行二分搜索，在单个元素的后面，则成对的元素变为奇数索引后跟他们的同一元素。说明我们在检索单个元素后面的偶数索引时，其后都没有它的同一元素。因此，我们可以通过偶数索引确定单个元素在左侧还是右侧。
　　算法：
1.奇数长度的数组首尾元素索引都为偶数，因此我们可以将 left 和 right 设置为数组首尾。
2.我们需要确保 mid 是偶数，如果为奇数，则将其减 1。
3.然后，我们检查 mid 的元素是否与其后面的索引相同。
4.如果相同，则我们知道 mid 不是单个元素。且单个元素在 mid 之后。则我们将 left设置为 mid + 2。
5.如果不是，则我们知道单个元素位于 mid，或者在 mid 之前。我们将 hi 设置为 mid。
6.一旦 lo == hi，则当前搜索空间为 1 个元素，那么该元素为单个元素，我们将返回它。

  class Solution {
    public int singleNonDuplicate(int[] nums) {
        int left = 0;
        int right = nums.length - 1;
        while(left < right){
            int mid = left + (right - left) / 2;
            if(mid % 2 ==1){
                mid = mid - 1;
            }
            if(nums[mid] == nums[mid+1]){
                left = mid + 2;
            }else{
                right = mid;
            }
        }
        return nums[left];
    }
}

4.LeetCode278. 第一个错误的版本

题目：
　　你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。
　　假设你有 n 个版本 [1, 2, …, n]，你想找出导致之后所有版本出错的第一个错误的版本。
　　你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。
示例:
　　给定 n = 5，并且 version = 4 是第一个错误的版本。
　　调用 isBadVersion(3) -> false
　　调用 isBadVersion(5) -> true
　　调用 isBadVersion(4) -> true
　　所以，4 是第一个错误的版本。
解题思路：
　　使用经典的二分算法查找。

　　场景一中，isBadVersion(mid) 返回 false，因此我们知道mid 左侧（包括自身）的所有版本都是正确的。所以我们令 left=mid+1，把下一次的搜索空间变为 [mid+1,right]。
　　场景二：isBadVersion(mid) => true

　　场景二中，isBadVersion(mid) 返回 true，因此我们知道 mid右侧（不包括自身）的所有版本的不可能是第一个错误的版本。所以我们令right=mid，把下一次的搜索空间变为[left,mid]。
　　在二分查找的每次操作中，我们都用 left 和 right 表示搜索空间的左右边界，因此在初始化时，需要将 left 的值设置为 1，并将 right 的值设置为 n。当某一次操作后left 和right 的值相等，此时它们就表示了第一个错误版本的位置。

  /* The isBadVersion API is defined in the parent class VersionControl.
      boolean isBadVersion(int version); */

public class Solution extends VersionControl {
    public int firstBadVersion(int n) {
        int left = 1;
        int right = n;
        while(left < right){
            int mid = left + (right - left) / 2;
            if(isBadVersion(mid)){
                right = mid;
            }else{
                left = mid + 1;
            }
        }
        return left;
    }
}

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

一文解决４道【搜索旋转排序数组】

【1】题目：
　　 假设按照升序排序的数组在预先未知的某个点上进行了旋转。
　　( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
　　请找出其中最小的元素。
　　你可以假设数组中不存在重复元素。
示例 1:
　　输入: [3,4,5,1,2]
　　输出: 1
示例 2:
　　输入: [4,5,6,7,0,1,2]
　　输出: 0
解题思路：
　　如果数组没有被旋转，是升序排列，就满足 last element > first element

　上图例子中 7>2 。说明数组仍然是有序的，没有被旋转。

　　上面的例子中 3 < 4，因此数组旋转过了。这是因为原先的数组为 [2, 3, 4, 5, 6, 7]，通过旋转较小的元素 [2, 3] 移到了后面，也就是 [4, 5, 6, 7, 2, 3]。因此旋转数组中第一个元素 [4] 变得比最后一个元素大。
　　这意味着在数组中你会发现一个变化的点，这个点会帮助我们解决这个问题，我们称其为变化点。　
在这个改进版本的二分搜索算法中，我们需要找到这个点。下面是关于变化点的特点：
　　所有变化点左侧元素 > 数组第一个元素
　　所有变化点右侧元素 < 数组第一个元素
算法：
　　１.找到数组的中间元素 mid。
　　２.如果中间元素 > 数组最后一个元素，我们需要在 [mid+1,right] 右边搜索变化点。
　　３.如果中间元素 < 数组最后一个元素，我们需要在 [left,mid] 左边搜索变化点。

class Solution {
    public int findMin(int[] nums) {
        int left = 0;
        int right = nums.length - 1;
        while(left < right){
            int mid = left + (right - left) / 2;
            if(nums[mid] > nums[right]){
                left = mid + 1; 
            }else{
                right = mid;
            }   
        }
        return nums[left];
    }
}

【2】33. 搜索旋转排序数组
题目：
　　假设按照升序排序的数组在预先未知的某个点上进行了旋转。
　　( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )
　　搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -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
解题思路：
　　根据旋转数组的特性，当元素不重复时，如果 nums[i] <= nums[j]，说明区间 [i,j] 是「连续递增」的。
　　i、j 可以重合，所以这里使用的比较运算符是「小于等于」
　　因此，在旋转排序数组中查找一个特定元素时：
　　（１）若 target == nums[mid]，直接返回
　　（２）若 nums[left] <= nums[mid]，说明左侧区间 [left,mid]「连续递增」。此时：
　　　　　①若 nums[left] <= target <= nums[mid]，说明 target 位于左侧。令 right = mid-1，在左侧区间查找
　　　　　②否则，令 left = mid+1，在右侧区间查找
　　（３）否则，说明右侧区间 [mid,right]「连续递增」。此时：
　　　　　①若 nums[mid] <= target <= nums[right]，说明 target 位于右侧区间。令 left = mid+1，在右侧区间查找
　　　　　②否则，令 right = mid-1，在左侧区间查找

class Solution {
    public int search(int[] nums, int target) {
        if(nums.length == 0){
            return -1;
        }
        int left = 0;
        int right = nums.length - 1;
        while(left <= right){
            int mid = left + (right - left) / 2;
            if(nums[mid] == target){
                return mid;
            }
            //[left,mid]连续递增
            if(nums[mid] >= nums[left]){
                if(nums[left] <= target && nums[mid]>= target){
                    right = mid - 1;
                }else{
                    left = mid + 1;
                }
            }else{
                if(nums[mid] <= target && nums[right]>= target){
                    left = mid + 1;
                }else{
                    right = mid - 1;
                }
            }
        }
        return -1; 
    }
}

【３】81. 搜索旋转排序数组-ii
题目：
　　假设按照升序排序的数组在预先未知的某个点上进行了旋转。
　　( 例如，数组 [0,0,1,2,2,5,6] 可能变为 [2,5,6,0,0,1,2] )。
　　编写一个函数来判断给定的目标值是否存在于数组中。若存在返回 true，否则返回 false。
示例 1:
　　输入: nums = [2,5,6,0,0,1,2], target = 0
　　输出: true
示例 2:
　　输入: nums = [2,5,6,0,0,1,2], target = 3
　　输出: false
解题思路：
　　这道题是上一题的升级版，元素可以重复。当 nums[left] == nums[mid] 时，无法判断 target 位于左侧还是右侧，此时无法缩小区间，退化为顺序查找。令 left++，去掉一个干扰项，本质上还是顺序查找：

class Solution {
    public boolean search(int[] nums, int target) {
         if(nums.length == 0){
            return false;
        }
        int left = 0;
        int right = nums.length - 1;
        while(left <= right){
            int mid = left + (right - left) / 2;
            if(nums[mid] == target){
                return true;
            }
            //[left,mid]连续递增
            if(nums[mid] > nums[left]){
                if(nums[left] <= target && nums[mid]>= target){
                    right = mid - 1;
                }else{
                    left = mid + 1;
                }
            }else if(nums[mid] < nums[left]){
                if(nums[mid] <= target && nums[right]>= target){
                    left = mid + 1;
                }else{
                    right = mid - 1;
                }
            }else{
                left++;
                continue;
            }
        }
        return false; 
    }
}

【４】[剑指Offer——(11)旋转数组的最小数字]
(https://blog.csdn.net/weixin_43180675/article/details/105230762)
这道题是【１】的升级版本。

总结：
　　在旋转排序数组中进行二分查找时，无论是搜索特定值，还是搜索最小值，都需要在左右两个区间里，找到「连续递增」的那个区间。
　　判断区间是否「连续递增」，只需比较区间边界值：如果 nums[left] <= nums[mid]，则区间 [left,mid] 连续递增；反之，区间 [mid,right] 连续递增。但是上述判断仅适用于数组中不含重复元素的情况，如果数组中包含重复元素，那么在 nums[left]==nums[mid] 时将退化为线性查找。
　　找到「连续递增」的区间后，问题就变得简单了许多：
　　33 题，查找特定值：只需要判断目标值在「连续递增」区间内还是区间外。比如当区间 [left,mid] 连续递增时，若目标值位于该区间内，则 right = mid-1；若目标值位于该区间外，则 left = mid+1。如果是区间 [mid,right] 连续递增，也可以用类似的方法收缩区间
153 题，查找最小值：只需要排除左侧或者右侧的一段「连续区间」，使得 [left,right] 不连续，就可以找到最小值。

6.LeetCode34. 在排序数组中查找元素的第一个和最后一个位置

题目：
　　给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
　　你的算法时间复杂度必须是 O(log n) 级别。
　　如果数组中不存在目标值，返回 [-1, -1]。
示例 1:
　　输入: nums = [5,7,7,8,8,10], target = 8　
　　输出: [3,4]
示例 2:
　　输入: nums = [5,7,7,8,8,10], target = 6
　　输出: [-1,-1]
解题思路：
如何寻找左边界呢？
　　1.1如果nums[mid] < target，那么左边没有target。left = mid+1，
　　1.2如果nums[mid]==target，在正常的二分查找中，这种情况是可以直接返回结果。但是因为我们是要查找左边界，这就有可能mid的左边还有可能有target这个数。因此需要进行两步操作。
　　　　1.2.1 用一个变量res标记mid的值，如果左边还有数值等于target，则更新res的值。否则直接返回res即可。
　　　　1.2.2 right= mid - 1，继续向左查找。
　　1.3 如果nums[mid] > target, 同1.2.2 right = mid - 1，继续向左查找。
如何寻找右边界呢？
　　2.1如果nums[mid] > target，那么右边没有target。right = mid - 1，
　　2.2如果nums[mid]==target，在正常的二分查找中，这种情况是可以直接返回结果。但是因为我们是要查找右边界，这就有可能mid的右边还有可能有target这个数。因此需要进行两步操作。
　　　　2.2.1 用一个变量res标记mid的值，如果左边还有数值等于target，则更新res的值。否则直接返回res即可。
　　　　2.2.2 left= mid + 1，继续向右查找。
　　2.3 如果nums[mid] < target, 同1.2.2left = mid + 1，继续向右查找。

class Solution {
    public int[] searchRange(int[] nums, int target) {
        if(nums == null || nums.length ==0){
            return new int[]{-1,-1};
        }
        return new int[]{searchLeft(nums,target),searchRight(nums,target)};
    
    }
    private int searchLeft(int[] nums, int target){
        int left = 0;
        int right = nums.length - 1;
        int res = -1;
        while(left <= right){
            int mid = left + (right - left) / 2;
            if(nums[mid] >= target){
                if(nums[mid] == target){
                    res = mid;
                }
                right = mid - 1;
            }else{
                left = mid + 1;              
            }
        }
        return res;
    }

    private int searchRight(int[] nums, int target){
        int left = 0;
        int right = nums.length - 1;
        int res = -1;
        while(left <= right){
            int mid = left + (right - left) / 2;
            if(nums[mid] <= target){
                if(nums[mid] == target){
                    res = mid;
                }
                left = mid + 1;
            }else{
                right = mid - 1;        
            }
        }
        return res;
    }
       
}