leetcode刷题之二分查找

首先了解一下二分法的算法，在下面的网址中进行学习
二分算法
69. x 的平方根
给你一个非负整数 x ，计算并返回 x 的 算术平方根 。由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。

class Solution(object):
    def mySqrt(self, x):
        l, r, ans = 0,x,-1
        while l <= r:
            mid = (l + r) // 2
            if mid * mid <= x: # 如果中间值的平方小于x
               ans = mid # 因为ans不能超过x 所以在<=这里面更新
               l = mid + 1 # 将左下标设置的靠右点 ，左半部分就可以舍弃了
            else:
                r = mid - 1 # 相反 右边界到 mid-1的位置
        return ans

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

class Solution(object):
    def nextGreatestLetter(self, letters, target):
        l = 0
        r = len(letters)-1
        ans = None
        while l <= r:
            mid = (l + r)//2
            if letters[mid] <= target:
                ans = mid
                l = mid + 1
            else:
                r = mid - 1
          
        return letters[l % len(letters)]  #  %  表示返回左操作数除以右操作数后的余数

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

class Solution(object):
    def singleNonDuplicate(self, nums):
        left = 0
        right = len(nums) - 1
        
        while left < right:
            mid = left + (right - left) // 2 # mid的值要放在循环内部 否则会导致mid不更新陷入死循环
            if mid % 2 == 1:
                mid -=  1
            if nums[mid] == nums[mid + 1]:
                left = mid + 2
            else:
                right = mid
        return nums[left]

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

class Solution(object):
    def firstBadVersion(self, n):
        l = 1
        r = n
        while l < r:
            mid =l +(r - l)//2
            if isBadVersion(mid):
                r = mid
            else:
                l = 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].给你一个元素值 互不相同 的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。

class Solution(object):
    def findMin(self, nums):
        l = 0
        r = len(nums)-1
        while l < r :
            mid = l + (r - l)//2
            if nums[mid] <= nums[r]:
                r = mid
            else:
                l = mid + 1
                # 这个地方让 l = mid 或者l = mid - 1 都会超出时间限制
                # 让l = mid + 1是为了让搜索范围减半
        return nums[l]

34. 在排序数组中查找元素的第一个和最后一个位置
给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

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

class Solution:
    def searchRange(self, nums, target):
        def search(target):
            # 初始二分查找范围为整个数组[0, n)
            left, right = 0, len(nums)
            # 找到首个大于target的值
            while left < right:
                mid = left + ((right - left) >> 1) # 获取中间值
                if nums[mid] > target:
                    right = mid    # 找到一个大于target的值，暂存并在左半区间继续查找
                else:
                    left = mid + 1 # 没有找到大于target的值，在右半区间继续查找
            return right

        # 首个target如果存在，一定是首个大于target-1的元素
        start = search(target - 1)
        if start == len(nums) or nums[start] != target:
            return [-1, -1]    # 首个target不存在，即数组中不包含target
        # 找到首个大于target的元素，最后一个target一定是其前一位
        end = search(target)
        return [start, end - 1]