LeetCode 二分法查找 (Python3)

Q33 搜索旋转排序数组 Search in Rotated Sorted Array

升序排列的整数数组 nums 在预先未知的某个点上进行了旋转（例如， [0,1,2,4,5,6,7] 经旋转后可能变为 [4,5,6,7,0,1,2] ）。
请你在数组中搜索 target ，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。

这道题我是根本没有看懂啊，看到很多评论是用二分法做的，但是由于这道题也没有要求时间复杂度O(logn)，我就用自己的方法写了

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        return nums.index(target) if target in nums else -1

这种使用内置函数的当然是不对的。。。

Q34 在排序数组中查找元素的第一个和最后一个位置 Find First And Last Position of Element in Sorted Array

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

这道题既然提出了时间复杂度的要求，那么就是要求使用二分法来做这道题。我也很久没有使用过这个方法了，好好的复习了一下。二分法大致是用在已经排序过的数组中，通过判断中间值与目标值的大小来分割判断区域，从而快速的查找到目标值。由于这道题需要找两个边界值，那么就需要用到两次二分法，时间复杂度为O(log2n).

下面这段代码是我根据一个java代码修改的，但是我并不是很能理解他的思路

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        lst=[-1,-1]
        left=0
        right=len(nums)-1

        if not nums:
            return lst

        while left<right: #第一轮查找
            mid=(left+right)//2 #对于python两种写法都是可以的
            if nums[mid]>=target: #找左边界，即位置最低的target
                right=mid #由于可以等于target的时候查找，所以分边界可以让right等于mid
            else:
                left=mid+1

        if nums[left]==target: #判断是否查找到了目标值，如果没有就直接返回[-1,-1]
            lst[0],lst[1]=left,left
        else:
            return lst
		#此时left与right已经发生了改变
        right=len(nums) #此时left没有改变，仍然是作为左边界的索引
        while left<right: #第二轮查找
            mid = (left+right)//2
            if nums[mid]<=target:
                left=mid+1
            else:
                right=mid
        lst[1]=left-1

        return lst

这道题不能干写，需要明白的是查找的第一个左边界指的是第一个等于target的数的位置，右边界指的是第一个大于target的数的位置减一，当然，这一切的前提在于题目提供的是升序数组，若是倒序或者是乱序就另当别论了

我在题解里面看到了一个人用python写的，感觉更加容易理解。他先是将二分法作为函数然后调用便可以了，最后a的结果就是第一个等于target的数的位置，b的结果就是第一个大于target的数的位置，所以最后答案需要将b-1

class Solution(object):
    def searchRange(self,nums, target):
        
        def left_func(nums,target):#二分法函数
            n = len(nums)-1
            left = 0
            right = n
            while(left<=right):
                mid = (left+right)//2
                if nums[mid] >= target:
                    right = mid-1
                if nums[mid] < target:
                    left = mid+1
            return left
            
        a =  left_func(nums,target)
        b = left_func(nums,target+1)
        
#当索引值等于数组长度意味着该数比数组中所有数都大（因为索引最大值为len(nums)-1），也就不会存在于数组中
        if  a == len(nums) or nums[a] != target: 
            return [-1,-1]
        else:
            return [a,b-1]

但是看完这两种方法的代码我又晕了，为什么在二分法查找阶段，第一个代码中是让right=mid，而第二个代码中是让right=mid-1？之后发现原因出在他们的while循环条件，如果条件是<，那么便是right=mid；如果条件是<=，那么便是right=mid-1

同时，这两种方法中的二分法while循环时并没有return任何值，这就会导致循环会一直持续，直到最后所查找的索引值为left。

Q35 搜索插入位置

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。

这道题基本就是最基础的二分法查找了，代码如下：

def binarySearch(nums, target):
    left=0
    right=len(nums)-1
    while left<right:
        mid=(left+right)//2
        if nums[mid]>target: #说明目标值target在nums[mid]左边，将右边界缩小
            right=mid
        elif nums[mid]<target: #说明目标值target在nums[mid]右边，将右边界增大
            left = mid + 1
        else:
            return mid #返回查找的目标值在数组中的索引
    return left

Q69 x的平方根 Sqrt(x)

实现 int sqrt(int x) 函数。
计算并返回 x 的平方根，其中 x 是非负整数。
由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。

思路也是使用二分法

class Solution:
    def mySqrt(self, x: int) -> int:
        if x==1:
            return 1
        minNum=0
        maxNum=x
        while maxNum-minNum>1:
            m=(maxNum+minNum)//2
            if x/m<m:
                maxNum=m
            else:
                minNum=m

        return minNum

Q74 搜索插入位置 Search a 2D Matrix

编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。该矩阵具有如下特性：
每行中的整数从左到右按升序排列。
每行的第一个整数大于前一行的最后一个整数。

这道题的思路和最普遍的二分查找类似，由于每一行都是升序序列那么遍历每一行做二分查找即可：

class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        def binarySearch(nums,target):
            left=0
            right=len(nums)-1
            while left<=right:
                mid=left+(right-left)//2
                if nums[mid]>target:
                    right=mid-1
                elif nums[mid]<target:
                    left=mid+1
                else:
                    return True
            return False
        
        for row in matrix:
            if binarySearch(row,target)==True:
                return True
        return False

Q275 H 指数 II H-Index II

给定一位研究者论文被引用次数的数组（被引用次数是非负整数），数组已经按照 升序排列 。编写一个方法，计算出研究者的 h 指数。

h 指数的定义: “h 代表“高引用次数”（high citations），一名科研人员的 h 指数是指他（她）的 （N 篇论文中）总共有 h 篇论文分别被引用了至少 h 次。（其余的 N - h 篇论文每篇被引用次数不多于 h 次。）"

这道题使用二分查找的方法，需要注意的是查找的目标值变成了每一次余留的长度，根据题意查找得出最终值

    def hIndex(self, citations: List[int]) -> int:


        left=0
        right=len(citations)-1
        while left<=right:
            mid=left+(right-left)//2
            if citations[mid]==len(citations)-mid:
                return citations[mid]
            if citations[mid]<len(citations)-mid:
                left=mid+1
            else:
                right=mid-1
        return len(citations)-left 

剑指 Offer 53 - II. 0～n-1中缺失的数字

一个长度为n-1的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围0～n-1之内。在范围0～n-1内的n个数字中有且只有一个数字不在该数组中，请找出这个数字。

二分法查找是否当前值与索引值相同，如果不同，必然会出现当前值大于索引值的情况，此时目标值即为索引值，当前值大于目标值，右边界缩小，相反左边界缩小。

最后left就是遍历结束时的索引值，也为缺失的那一个数的值

class Solution:
    def missingNumber(self, nums: List[int]) -> int:
        left=0
        right=len(nums)-1
        while left<=right:
            mid=left+(right-left)//2
            if nums[mid]!=mid:
                right=mid-1
            else:
                left=mid+1
        return left

一些笔记

1. 二分法基本代码第一种：（记住这一种吧）

   def binarySearch(nums, target):
       left=0
       right=len(nums)-1
       while left<=right:
           mid=left+(right-left)//2
           if nums[mid]>target: #说明目标值target在nums[mid]左边，将右边界缩小
               right=mid-1
           elif nums[mid]<target: #说明目标值target在nums[mid]右边，将右边界增大
               left = mid + 1
           else:
               return mid #返回查找的目标值在数组中的索引
   

   二分法基本代码第一种：

   def binarySearch(nums, target):
       left=0
       right=len(nums)
       while left<right:
           mid=left+(right-left)//2
           if nums[mid]>target: #说明目标值target在nums[mid]左边，将右边界缩小
               right=mid
           elif nums[mid]<target: #说明目标值target在nums[mid]右边，将右边界增大
               left = mid + 1
           else:
               return mid #返回查找的目标值在数组中的索引
   

   二者的区别是：

   1. 右边界定义不同
   2. while循环判断条件不同
   3. 右边界在if后的取值不同

2.二分法while循环时如果没有return任何值，这就会导致循环会一直持续，直到最后所查找的索引值为left。

3.mid=(left+right)//2和mid=left+(right-left)//2都行，注意python中一定要用到//整除，考虑到可能发生的整型溢出，使用mid=left+(right-left)//2取mid更安全一点