leetcode力扣_二分查找（已完结）

目录

69.x的平方根

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

540.有序数组中的单一元素

278.第一个错误的版本

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

---

69.x的平方根

        给你一个非负整数 x ，计算并返回 x 的 算术平方根 。由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。

示例 1：

输入：x = 4
输出：2

示例 2：

输入：x = 8
输出：2
解释：8 的算术平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。

 解题思路：

① 第一种就是暴力解法，因为 x 开方之后的值肯定是小于等于其本身的，所以定义一个变量 i 让它从 0~i 遍历并比较i*i 和 x 的大小，注意返回的值是 i 还是 i+1 。代码如下

class Solution {
public:
    int mySqrt(int x) {
        //这里使用long long int是防止i*i的计算结果产生溢出
        long long int i ;
        //这样解法的复杂度是O(根号x)
        while((i*i) <= x){
            i++ ;
        }
        return i-1 ;
    }
};

② 第二种是二分查找法，二分查找的下界设置为 0 ，上界设置为 x ，定义一个中间变量 mid ，然后将 mid 做如下定义，这样定义的目的是防止越界，如果直接定义为 (right + left) / 2 在计算过程中，(right + left) 的结果可能会超出 int 所能表达的最大数字。

int mid = left + (right - left) / 2 ;

         当然可以直接将 min 定义成 long long int 型，个人感觉这样更好一点，后面计算 mid * mid 的时候也不用在前面加上 long long 了。代码如下：

class Solution {
public:
    int mySqrt(int x) {
        int left = 0 ;
        int right = x ;
        int ans = -1 ;
        while(left<=right){
            long long int mid = left + (right - left) / 2 ;
            if(mid * mid == x){
                ans = mid ;
                break ;//没有break就会超时，因为这里后面的语句没有执行也就没有更新left和right
            }else if(mid * mid > x){
                right = mid-1 ;
            }else{
                left = mid+1 ;
                ans = mid;
            }
        }
        return ans ;
    }
};

 ③ 官方题解中还有一个牛顿迭代法，大概看了一下，涉及了函数求零点问题，还要求导啥的感觉太麻烦了。正常估计也想不到要用这个方法。

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

        给你一个字符数组 letters，该数组按非递减顺序排序，以及一个字符 target。letters 里至少有两个不同的字符。返回 letters 中大于 target 的最小的字符。如果不存在这样的字符，则返回 letters 的第一个字符。

示例 1：

输入: letters = ["c", "f", "j"]，target = "a"
输出: "c"
解释：letters 中字典上比 'a' 大的最小字符是 'c'。

示例 2:

输入: letters = ["c","f","j"], target = "c"
输出: "f"
解释：letters 中字典顺序上大于 'c' 的最小字符是 'f'。

示例 3:

输入: letters = ["x","x","y","y"], target = "z"
输出: "x"
解释：letters 中没有一个字符在字典上大于 'z'，所以我们返回 letters[0]。

提示：

• 2 <= letters.length <= 104
• letters[i] 是一个小写字母
• letters 按非递减顺序排序
• letters 最少包含两个不同的字母
• target 是一个小写字母

解题思路：

① 同样可以使用二分查找，思路和上一个题目基本一模一样。

代码如下：

class Solution {
public:
    char nextGreatestLetter(vector<char>& letters, char target) {
        int right = letters.size() - 1 ;
        int left = 0;
        if(target >= letters[right]){
            return letters[0] ;
        }
        while(left < right){
            int mid = (left + right) / 2 ;
            if(letters[mid] > target){
                //这里下标为mid的字符已经比target大了
                //所以可能是目标字符也可能不是（因为不保证它是第一个比它大的）
                //所以更新时不能将它直接跳过，要以它为有边界
                right = mid  ;
            }else{
                //这里为什么是mid+1,因为这里else的潜在条件是letters[mid] <= target
                //而我们要找的是第一个‘大于’target的字符，所以下标为mid的字符一定不会是目标字符
                //因此更新left时就可以跳过这一个，直接将mid+1作为左边界重新寻找
                left = mid + 1;
            }
        }
        return letters[left] ;
    }
};

另外还有一个版本的代码，和上一个区别就是while的条件不一样了，然后right的更新情况不一样。emmm...其实感觉很费解，有点转不过来弯儿，为什么是这个样子。

【好好意会一下其实也能想通，就是不知道以后遇到了能不能想起来，哈哈】

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

 ② 还有一种就是直接解咯，当然上面用二分查找法是为了练习一下这个算法，直接解就非常easy,遍历一下就完事了，毫无技巧。

class Solution {
public:
    char nextGreatestLetter(vector<char>& letters, char target) {
        int len = letters.size() ;
        int i = 0;
        for( ; i<len ;i++){
            if(letters[i] > target){
                return letters[i] ;
            }
        }
        return letters[0] ;
    }
};

540.有序数组中的单一元素

        给你一个仅由整数组成的有序数组，其中每个元素都会出现两次，唯有一个数只会出现一次。请你找出并返回只出现一次的那个数。你设计的解决方案必须满足 O(log n) 时间复杂度和 O(1) 空间复杂度。

示例 1:

输入: nums = [1,1,2,3,3,4,4,8,8]
输出: 2

示例 2:

输入: nums =  [3,3,7,7,10,11,11]
输出: 10

提示:

• 1 <= nums.length <= 105
• 0 <= nums[i] <= 105

解题思路：

① 刚开始在想这怎么用二分查找来做呢，想了一下感觉不是很友好，然后就先用自己的想法做了，每个元素都会成对出现，唯有一个数只会出现一次。那么只需要遍历下标 i 是奇数的数据，然后比较 nums[i-1] 和 nums[i] 是否相等，相等时执行 i = i + 2 ，继续遍历，不相等时就可以直接返回 nums[i-1] 了，个人感觉这个非常好理解，但是时间复杂度🤔是多少，看起来应该是不满足题目要求的。

class Solution {
public:
    int singleNonDuplicate(vector<int>& nums) {
        int len = nums.size() ;
        int i ;
        for(i = 1 ;i<len; i=i+2){
            int key = nums[i] ;
            if(nums[i-1] == nums[i]){
                continue ;
            }else {
                return nums[i-1];
            }
        }
        return nums[len-1] ;
    }
};

问了一下GPT,时间复杂度是O(n)【我还以为是O(n/2)】。

已老实 求放过

② 尝试使用二分查找，二分查找的时间复杂度是 O(log n) ,只能从数据的个数下手了【奇数偶数】，因为数据都是成对出现，单独的数据出现的时候，它前面和后面的数据个数一定是偶数个，由于下标是从 0 开始的，所以目标数据 key 的下标 i 一定是偶数！那我们就来看下标是偶数的数据。解释写在代码注释里了。

class Solution {
public:
    int singleNonDuplicate(vector<int>& nums) {
        int right = nums.size() - 1 ;
        int left = 0 ;
        while(left<right){
            int mid = ( right + left )/2 ;
            if(mid % 2 == 0){
                //mid是偶数 且mid和mid+1指向的数相同，说明key还没有出现
                //更新左边界，在数据的右半部分继续查找
                if(nums[mid] == nums[mid+1]){
                    left = mid + 2 ;
                }else {
                    //mid和mid+1指向的数不相同，说明key已经出现
                    //key出现之后两个相同数据的索引才会由“偶奇”变为“奇偶”
                    //更新右边界，在数据的左半部分继续查找
                    //因为要找的Key也有可能就是下标为mid的数据，故right = mid
                    right = mid ;
                }
            }else{
                //mid是奇数时同理，比较“偶奇”指向的数，相同则说明key还未出现
                //此时更新左边界为下一个偶数 即 mid+1
                if(nums[mid-1] == nums[mid]){
                    left = mid + 1 ;
                }else {
                    //若是不相同 说明key已经出现 操作同上一部分
                    right = mid ;
                }
            }
        }
        return nums[left] ;
    }
};

278.第一个错误的版本

        你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。假设你有 n 个版本 [1, 2, ..., n]，你想找出导致之后所有版本出错的第一个错误的版本。你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。

示例 1：

输入：n = 5, bad = 4
输出：4
解释：
调用 isBadVersion(3) -> false 
调用 isBadVersion(5) -> true 
调用 isBadVersion(4) -> true
所以，4 是第一个错误的版本。

示例 2：

输入：n = 1, bad = 1
输出：1

提示：

• 1 <= bad <= n <= 231 - 1

 解题思路：可以遍历也可以二分查找，当然不管题目中的“你应该尽量减少对调用 API 的次数。”这句话，使用遍历方法是最容易想到的，就把 n 从 1 到 n 都遍历一下，看返回函数第一次出现 true 是几就返回几。这里使用二分查找的方法来写，已经比较熟练了

代码如下，需要注意的事项已标注在代码中。

// The API isBadVersion is defined for you.
// bool isBadVersion(int version);

class Solution {
public:
    int firstBadVersion(int n) {
        int left = 1 ;
        int right = n ;
        while(left < right){
            long long int mid = left / 2 + right / 2 ;
            //这种不行，因为(left + right)默认为int型，但是当left和right都很大时，int型无法表示二者之和
            //long long int mid = (left + right) / 2; 

            //int mid = left + (right - left) / 2 ; 这样是可以的
            if(isBadVersion(mid) == false){
                left = mid + 1;
            }else{
                right = mid ;
            }
        }
        return left ;
    }
};

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] ，旋转 3 次得到输入数组。

提示：

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

 解题思路：根据题目描述，这一段数组是两段升序数据，且第一段的所有数据均大于第二段的数据(一般情况下)，所以可以利用二分查找找到最小值。下面是我写的代码，我将中间值 nums[mid] 与左端点的值进行比较了，这样需要考虑得稍微复杂一点。

class Solution {
public:
    int findMin(vector<int>& nums) {
        int left = 0 ;
        int right = nums.size() - 1 ;
        while(left<right){
            int mid = (left + right) / 2 ;
            // 这样写保证了mid对应的数是在左侧上升段
            if((nums[mid] >= nums[left]) && (nums[mid] >= nums[right])){
                left = mid + 1 ;
            }else {
                right = mid ;
            }
        }
        return nums[left] ;
    }
};

        看了一下官方思路，它是将中轴元素 nums[pivot] 与右边界元素 nums[high] 进行比较，这样比较关系比较明了，只会出现两种可能，一是 nums[pivot] 小于 nums[high] ，因此可以忽略二分查找区间的右半部分。

 另外一种是 nums[pivot] 大于 nums[high] ，因此可以忽略二分查找区间的左半部分。

 由于 pivot 是 （high + low）./ 2 计算得来的，且数据没有相同的，故不会出现 nums[pivot] = nums[high] 的情况。根据官方思路写出来的代码如下：

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

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

        给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

示例 1：

输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]

示例 2：

输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]

示例 3：

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

提示：

• 0 <= nums.length <= 105
• -109 <= nums[i] <= 109
• nums 是一个非递减数组
• -109 <= target <= 109

 解题思路：最直观的思路，可以用两个二分查找，一个用来找到开始位置，一个用来找到结束位置。代码如下，一些小细节备注在代码中了

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int left = 0 ;
        int right = nums.size() - 1 ;
        vector<int> a(2,-1) ;
        if(right < 0){
            return a ;
        }
        while(left < right){
            int mid = (left + right) / 2 ;
            if(nums[mid] < target){
                left = mid + 1 ;
            }else{
                right = mid ;
            }
        }
        //要有这一步判断来确定是否找到了目标值
        if (nums[left] != target) {
            return a;
        }else{
            a[0] = left;
        }
        //这里只需要重置有边界就可以了，因为左边界已经找到了
        right = nums.size() - 1 ;
        while(left < right){
            int mid = (left + right + 1) / 2 ;//这里不加一的话 会陷入死循环
            if(nums[mid] > target){
                right = mid - 1 ;
            }else{
                left = mid ;
            }
        }
        a[1] = right ;
        return a ;
    }
};

官方解题思路：考虑 target 开始和结束位置，其实我们要找的就是数组中「第一个等于 target 的位置」和「第一个大于 target 的位置减一」。试一下官方解题思路要怎么写，看起来应该不难的样子...maybe.

写不出来一点，为什么返回右边的值这么难搞，要不就是返回的值不对要不就是会陷入死循环。还是用我的方法吧，慢就慢点，一眼能看懂就行。

已老实 求放过