Leetcode刷题记录-二分查找

参考github大佬：
https://github.com/CyC2018/CS-Notes/blob/master/notes/Leetcode%20%E9%A2%98%E8%A7%A3%20-%20%E7%9B%AE%E5%BD%95.md

题目1 leetcode 704 （简单）二分查找

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

示例 1:
输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4

示例 2:
输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1

代码：

class Solution(object):
    def search(self, nums, target):
        low = 0
        high = len(nums) - 1  
        while low <= high:
            mid = (low + high) // 2
            if target == nums[mid]:
                return mid
            elif target > nums[mid]:
                low = mid + 1
            else:
                high = mid - 1            
        return -1

偶尔快

示例代码：

class Solution(object):
    def search(self, nums, target):
        left , right = 0 , len(nums)-1
        while left<=right:
            mid = left+(right-left)/2
            if target<nums[mid]:
                right=mid-1
            elif target>nums[mid]:
                left=mid+1
            else:
                return mid
        return -1

引用自github：
有两种计算中值 m 的方式：

m = (l + h) / 2
m = l + (h - l) / 2
l + h 可能出现加法溢出，也就是说加法的结果大于整型能够表示的范围。但是 l 和 h 都为正数，因此 h - l 不会出现加法溢出问题。所以，最好使用第二种计算法方法。

题目2 leetcode 69 （简单）求算术平方根

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

示例 1：
输入：x = 4
输出：2

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

提示：
0 <= x <= 2^31 - 1

代码：

class Solution(object):
    def mySqrt(self, x):     
        if x < 1:
            return x
        l , h = 1 , x 
        while l <= h :
            mid = l + (h - l) // 2
            step = x // mid
            if step == mid :            
                return mid
            elif step < mid :
                h = mid - 1 
            else:
                l = mid + 1
        return h

示例代码：

```python
class Solution(object):
    def mySqrt(self, x):
        """
        :type x: int
        :rtype: int
        """
        #l，r为二分查找左右值，res为结果
        l,r,res=0,x,-1
        while(l<=r):
            #注意：这里要使用整除
            mid=(l+r)//2
            if(mid*mid<=x):
                #如果当前中值小于等于x，则有可能是答案
                res=mid
                #l要继续逼近答案知道l>r
                l=mid+1
            else:
                r=mid-1
        
        return res

题目3 leetcode 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(object):
    def nextGreatestLetter(self, letters, target):
        l , h = 0 , len(letters) - 1 
        while l <= h :
            mid = l + (h - l) // 2
            if target >= letters[mid]:
                l = mid + 1 
            else:
                h = mid - 1
        return letters[l % len(letters)] 

示例代码：

class Solution(object):
    def nextGreatestLetter(self, letters, target):
        """
        :type letters: List[str]
        :type target: str
        :rtype: str
        """
        left , right = 0 , len(letters) - 1
        while left <= right:
            mid = left + (right - left) // 2
            if letters[mid] <= target:
                left = mid + 1
            elif letters[mid] > target:
                right = mid - 1
        return letters[left % len(letters)]

题目4 leetcode 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

代码：

class Solution(object):
    def singleNonDuplicate(self, nums):  
        l , h = 0 , len(nums) - 1 
        while l < h :
            mid = l + (h - l) // 2   
            if mid % 2 == 1 :
                mid = mid - 1
            if nums[mid] == nums[mid + 1]:
                l = mid + 2
            else:
                h = mid 
        return nums[l]

示例代码：

class Solution(object):
    def singleNonDuplicate(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        len_nums = len(nums)
        l, r = 0, len_nums - 1
        while l < r:
            m = (l + r) / 2
            #print m, l, r
            if m % 2 == 1:
                m -= 1
            if (nums[m] == nums[m + 1]):
                l = m + 2
            else:
                r = m
        return nums[r]
    

blog.csdnimg.cn/a0eeb234e5ca40369c505d08b7197690.png)

题目5 leetcode 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

代码：

class Solution(object):
    def firstBadVersion(self, n):
        l , h = 1 , n
        while l < h:
            mid = l + (h - l) // 2
            if isBadVersion(mid) :
                h = mid
            else:
                l = mid + 1
        return l

示例代码：

# The isBadVersion API is already defined for you.
# @param version, an integer
# @return a bool
# def isBadVersion(version):

class Solution(object):
    def firstBadVersion(self, n):
        """
        :type n: int
        :rtype: int
        """
        left,right=1,n
        while(left<right):
            midle=(left+right)//2
            if isBadVersion(midle):
                right=midle
            else:
                left=midle+1
        return left

题目6 leetecode 153 (中等) 寻找旋转排序数组中的最小值

代码：

class Solution(object):
    def findMin(self, nums):
        l , h = 0 , len(nums) - 1 
        while l < h :
            mid = l + (h - l) // 2
            if nums[mid] < nums[h]:
                h = mid 
            else:
                l = mid + 1
        return nums[l]

示例代码：

class Solution(object):
    def findMin(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """

        n = len(nums)
        left = -1
        right = n - 1

        while left + 1 < right:

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

            if nums[mid] > nums[-1]:

                left = mid

            else: 
                right = mid

        return nums[right]

题目7 leetcode 34 （中等）在排序数组中查找元素的第一个和最后一个位置

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

代码：

class Solution(object):
    def searchRange(self, nums, target):
        def findfrst( nums, target):
            l , h = 0 , len(nums) - 1
            while l <= h :
                mid = l + (h - l) // 2
                if nums[mid] >= target:
                    h = mid - 1
                else:
                    l = mid + 1 
            return l
        first = findfrst(nums, target)
        last = findfrst(nums, target + 1) - 1
        if first <= last:
            return [first, last]
        return [-1, -1]

示例代码：

class Solution(object):
    def searchRange(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        if len(nums) == 0:
            return [-1, -1]
        left, right, res = 0, len(nums) - 1, -1
        while left <= right:
            mid = (right - left) / 2 + left
            if nums[mid] == target:
                res = mid
                break
            elif nums[mid] > target:
                right = mid - 1
            else:
                left = mid + 1
        if res == -1:
            return [-1, -1]
        left, right = res, res
        while right + 1 < len(nums) and nums[right + 1] == target:
            right += 1
        while left -1 >= 0 and nums[left - 1] == target:
            left -= 1
        return [left, right]
            
            

总结：

二分法解题根据题目要求，对边界值、等号进行修改，若循环条件有l、h有等号，则右边界h减小时=m - 1，从len（nums）-1开始；无等号h = m，从len（nums）开始。

Tips：

1. 二分查找适用条件：升序排列、整型、无重复元素
2. 除号的区别：“//” 向下取整
3. 《算法图解》配套代码：https://github.com/egonSchiele/grokking_algorithms/blob/master/01_introduction_to_algorithms/python/binary_search.py

重写整合

###适用于升序整型数组,无重复元素

class Solution(object):
    def __init__(self, number, target, x, letters, target_letter, singelem_nums, finmin_nums, searchRg_nums, searchRg_target):
        self.nums = number
        self.target = target
        self.x = x
        self.letters = letters
        self.target_letter = target_letter
        self.singelem_nums = singelem_nums
        self.finmin_nums = finmin_nums
        self.searchRg_nums = searchRg_nums
        self.searchRg_target = searchRg_target


    # 1.简单二分查找，升序，整型，无重复
    def binary_search(self):

        low = 0
        high = len(self.nums) - 1

        while low <= high:
            mid = low + (high - low) // 2
            if self.target == self.nums[mid]:
                print('found the target number', self.target, ", the loc is", mid)
                return mid
            elif self.target > self.nums[mid]:
                low = mid + 1
            else:
                high = mid - 1
        print('cannot find the target', self.target)
        return -1


    # 2.求算术平方根，非负，向下取整
    def sqrt_inter(self):
        if self.x <= 1:
            print("sry, the number must be larger than one !")
            return self.x
        else:
            l, h = 1, self.x
            while l <= h:
                mid = l + (h - l) // 2
                step = self.x / mid
                if step == mid:
                    # 如果算术平方根是整数，则直接向下取整，取数组中位数
                    print("the inter sqrt of", self.x, " is ", mid)
                    return mid
                elif step < mid:
                    h = mid - 1
                else:
                    l = mid + 1
            # 如果算数平方根是小数则取数组的边界h
            print("the inter sqrt of", self.x, " is ", h)
            return h

    # 3.找比目标字母大的最小字母，若无则输出第一个
    def nextGreatestLetter(self):
        l , h = 0 , len(self.letters) - 1
        while l <= h :
            mid = l + (h - l) // 2
            if self.target_letter <= letters[mid]:
                h = mid - 1
            else:
                l = mid + 1
        print('the next greatest letter of ',"'",self.target_letter, "'",'is', "'",letters[l % len(letters)], "'")
        return letters[l % len(letters)]

    # 4.有序数组的 Single Element
    def select_singelem(self):
        l , h = 0 , len(self.singelem_nums) - 1
        # 因为h = m，若l = h则会陷入循环
        while l < h:
            mid = l + (h - l) // 2
            if mid % 2 == 1:
                mid -= 1
            # 若相等说明single element在右边范围，左边全是成对数字，所以左边界+2
            if self.singelem_nums[mid] == self.singelem_nums[mid + 1]:
                l = mid + 2
            else:
                # 右边界也有可能是答案，所以不能+1
                h = mid
        # 停止循环时l = h，返回左右边界都可以
        print('the single element is', self.singelem_nums[l])
        return self.singelem_nums[l]

    # 5.寻找旋转排序数组中的最小值
    def finmin_elem(self):
        l , h = 0 , len(self.finmin_nums) - 1
        while l < h :
            mid = l + (h - l) // 2
            if self.finmin_nums[mid] < self.finmin_nums[h]:
                h = mid
            else:
                l = mid + 1
        print('the min number is', finmin_nums[l])
        return finmin_nums[l]

    # 6.在排序数组中查找指定元素的第一个和最后一个位置
    def searchRange(self):
        # 分别查找第一个target和target+1的位置
        def findtarget(nums, target):
            l , h = 0 , len(nums) - 1
            while l <= h:
                mid = l + (h - l) // 2
                if nums[mid] >= target:
                    h = mid - 1
                else:
                    l = mid + 1
            return l
        first = findtarget(self.searchRg_nums, self.searchRg_target)
        last = findtarget(self.searchRg_nums, self.searchRg_target + 1) - 1
        if first <= last:
            print('the loc of the target number is',[first, last])
            return [first, last]
        return [-1, -1]










if __name__ == "__main__":
    # 1.简单二分查找参数
    number = [-1, 0, 3, 5, 9, 12]
    target = 12

    # 2.求x的算术平方根参数
    x = 36

    # 3.找比目标字母大的最小字母参数
    letters = ['c', 'f', 'j']
    target_letter = 'd'

    # 4.找有序数组的 Single Element参数
    singelem_nums = [3,3,7,7,10,11,11]

    # 5.寻找旋转排序数组中的最小值参数
    finmin_nums = [4,5,6,7,0,1,2]

    # 6.在排序数组中查找指定元素的第一个和最后一个位置参数
    searchRg_nums = [5,7,7,8,8,8,10]
    searchRg_target = 8


    numbers = Solution(number, target, x, letters, target_letter, singelem_nums, finmin_nums, searchRg_nums, searchRg_target)

    # 1.简单二分查找调用
    # numbers.binary_search()

    # 2.求x的算术平方根及调用
    # numbers.sqrt_inter()

    # 3.找比目标字母大的最小字母调用
    # numbers.nextGreatestLetter()

    # 4.找有序数组的 Single Element调用
    # numbers.select_singelem()

    # 5.寻找旋转排序数组中的最小值调用
    # numbers.finmin_elem()

    # 6.在排序数组中查找指定元素的第一个和最后一个位置调用
    numbers.searchRange()




    """ 二分查找模板
    /**
     * 范围查询规律
     * 初始化:
     *   int left = 0;
     *   int right = nums.length - 1;
     * 循环条件
     *   left <= right
     * 右边取值
     *   right = mid - 1
     * 左边取值
     *   left = mid + 1
     * 查询条件
     *   >= target值, 则 nums[mid] >= target时, 都减right = mid - 1
     *   >  target值, 则 nums[mid] >  target时, 都减right = mid - 1
     *   <= target值, 则 nums[mid] <= target时, 都加left = mid + 1
     *   <  target值, 则 nums[mid] <  target时, 都加left = mid + 1
     * 结果
     *   求大于(含等于), 返回left
     *   求小于(含等于), 返回right
     * 核心思想: 要找某个值, 则查找时遇到该值时, 当前指针(例如right指针)要错过它, 让另外一个指针(left指针)跨过他(体现在left <= right中的=号), 则找到了
     */
    """