***leetcode刷题_（剑指offer_11_二分法/ 53_二分查找排序数组中的数字）

code11: 旋转数组的最小值
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一个旋转，该数组的最小值为1。

示例 1：

输入：[3,4,5,1,2]
输出：1
示例 2：

输入：[2,2,2,0,1]
输出：0

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/xuan-zhuan-shu-zu-de-zui-xiao-shu-zi-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解答：
1 正常操作：遍历找到最小的值：O（N）

2 二分法进行查找：（寻找最小值）
1） 确定二分法的双边界，使用左右均闭的情况。初始值应该为[0,len-1]
2）确定二分法的循环包裹条件。中值>右值时，右包裹，[mid+1,r]；小于时，左包裹，[l,mid]。相等时，r-=1。
3）确定二分法的终止边界： l=r
4）确定二分法是否能够全部遍历到：左右包裹时完整分割数组，最终停留在r上的值是需要的。
注意：
1 这里的题意求最小值，所以我们包裹时要将最小值包裹进去、
2 最终求解值依托于r
3 一般的二分法有各种区间的处理，对应的终止条件也有所不同（针对查找是否存在某一个数字v）：
1） 双闭区间时，循环条件为：l<=r，所以终止的边界为l>r。
2）单闭区间时，循环条件为：l<r，所以终止的边界为l=r。

但是题目求解寻找最小值！！！
所以并不能按照一般情况来处理！

总结：
1 确定寻找的目标
2 确定目标所在范围
3 确定区间（目前我个人使用闭区间）
4 确定终止条件（l<r 或者 l<=r）
5 确保所有元素都可以被取到：左右包裹+相等时的操作等
6 确定终止时值的依托 l 或者 r

代码：
递归：

class Solution:#全闭[]
    def minArray(self, numbers) -> int:
        if len(numbers)==1:
            return numbers[0]
        res = self.bi_re(numbers, 0, len(numbers)-1)
        #print(res,'#')
        return numbers[res]

    def bi_re(self, numbers, l, r):
        if l < r:
            mid = (l + r) // 2
            #print(l,r,mid,numbers[mid],numbers[r])
            if numbers[mid] > numbers[r]:
                return self.bi_re(numbers, mid+1, r)
            elif numbers[mid] < numbers[r]:
                return self.bi_re(numbers, l, mid)
            else:
                return self.bi_re(numbers, l, r - 1)
        else:
            #print(l,r)
            return r

迭代：

class Solution:#全闭[]
    def minArray(self, numbers) -> int:
        l = 0
        r = len(numbers)-1
        while l<r:
            mid = (l+r)//2
            if numbers[mid]>numbers[r]:
                l = mid+1
            elif numbers[mid]<numbers[r]:
                r = mid
            else:
                r-=1
        return numbers[r]

普通的双闭二分查找：

class Solution:#双闭的时候，需要保证能取到r所以终止边界为l<=r
    def find(self,number,v):
        l=0
        r=len(number)-1
        while l<=r:
            mid = (l+r)//2
            if number[mid] == v:
                return mid
            elif number[mid]>v:
                r = mid-1
            else:
                l = mid+1
        return -1
su =Solution()
arr = [1,2,3,4,5,6,7,8,9]
tar = 8
res = su.find(arr,tar)
print(res)

**

面试题53 - I. 在排序数组中查找数字 I

**
统计一个数字在排序数组中出现的次数。

示例 1:

输入: nums = [5,7,7,8,8,10], target = 8
输出: 2
示例 2:

输入: nums = [5,7,7,8,8,10], target = 6
输出: 0

限制：

0 <= 数组长度 <= 50000

解答：
二分查找下边界，然后遍历比较返回相应的个数
使用bisect库函数寻找下边界即可
代码：

import bisect
class Solution:
    def search(self, nums: List[int], target: int) -> int:
        if not nums:
            return 0
        ind = bisect.bisect_left(nums,target)
        if ind>len(nums)-1:
            return 0
        #print(ind)
        #ind+=1
        count = 0
        while ind <=len(nums)-1:
            if nums[ind] == target:
                count+=1
                ind+=1
                #print(ind)
            else:
                return count
        return count

注意点：
1 bisect.bisect_left返回的index为下边界的预期index，即理论上该数插入时，后面数据应该右移动
2 边界情况，数组为空 直接返回0
3 边界情况，如果该数一直持续到数组结尾，但是最后的while循环不会做新的判定，直接在最后面加上return count即可。

同样关于二分的思想：全包裹数据，迭代时进行逼近
下边界的代码：

def lower_bound(nums: list, target: int) -> int:
    l = 0
    r = len(nums)
    while l<r:
        mid = l + (r-l)//2
        if nums[mid]<target:
            l = mid+1
        else:
            r = mid
    return l

这样操作以后返回的是l的最后值，即mid+1 。 是数组元素群最左边的index，和上面的bisect_left意思是一样的。