力扣100题---二分

        本来笔者今天打算写贪心，但是写到后面两题发现有些用例怎么都调都过不了，于是就来看看二分，没想到1个小时就把这6道二分的题目刷完了。

        二分的普适性不是很好，只能在有序的序列中才能使用，但是可以人为地使数列变得有序，所以二分也是常考的题目。

T1：搜索插入位置

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

请必须使用时间复杂度为 O(log n) 的算法。

示例 1:

输入: nums = [1,3,5,6], target = 5
输出: 2

示例 2:

输入: nums = [1,3,5,6], target = 2
输出: 1

这是一道标准的二分，但是是我收益最大的一题。

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

        这道题我在刚开始写的时候发现输出中出现了null，这时我才发现target值不只是有列表中存在的，还要求不存在插入。但是三根指针到最后的指向我是比较混乱的，我尝试使用了right处插入，发现两个用例均少了1，于是我加上1提交，居然通过了。
        这说明在标准的二分模版下，如果需要插入数字，就应该位于（right+1）处。

T2:搜索二维矩阵

给你一个满足下述两条属性的 m x n 整数矩阵：

• 每行中的整数从左到右按非严格递增顺序排列。
• 每行的第一个整数大于前一行的最后一个整数。

给你一个整数 target ，如果 target 在矩阵中，返回 true ；否则，返回 false 。

示例 1：

输入：matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3
输出：true

示例 2：

输入：matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 13
输出：false

        这道题本来我以为要使用类似于“二维二分”这种高级的方法，但是我尝试把它转化为1维，我担心这个转换过程可能会有比较高的复杂度，但是提交的时候通过了，我也就不再深究。

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

二维转换为一维后就是标准的二分了。

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

给你一个按照非递减顺序排列的整数数组 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]

  这道题在使用二分时，当找到第一个值，剩下该怎么找，按理说剩下的值都在这个位置两边或者一侧，界则是两个指针，所以我就采用从当前位置望两侧走的方式来完成。

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        left=0
        right=len(nums)-1
        ts=[]
        while left<=right:
            mid = (left+right)//2
            if target<nums[mid]:
                right=mid-1
            elif target>nums[mid]:
                left=mid+1
            else:
                ts.append(mid)
                for i in range(mid-1,left-1,-1):
                    if nums[i]==target:
                        ts.append(i)
                    else:
                        break
                for i in range(mid+1,right+1):
                    if nums[i]==target:
                        ts.append(i)
                    else:
                        break
                break

        if len(ts)!=0:
            ts.sort()
            return [ts[0],ts[-1]]
        else:
            return [-1,-1]

标准的二分，由于有延伸的部分所以代码看起来比较长。

T4:搜索旋转排序数组

整数数组 nums 按升序排列，数组中的值 互不相同 。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。

给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。

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

示例 1：

输入：nums = [4,5,6,7,0,1,2], target = 0
输出：4

示例 2：

输入：nums = [4,5,6,7,0,1,2], target = 3
输出：-1

 这道题的点在于顺序被打乱了，而二分必须要求有序。如果诸位看过我两天前发的哈希的题目，可能会对哈希有一点想法，如果使用哈希，那无论多乱也无所谓了，于是我使用了哈希并通过了该题目。

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        hash_map={}
        for i in range(len(nums)):
            hash_map[nums[i]]=i
        nums.sort()
        left=0
        ans=0
        right=len(nums)-1
        while left<=right:
            mid=(left+right)//2
            if target<nums[mid]:
                right=mid-1
            elif target>nums[mid]:
                left=mid+1
            else:
                return hash_map[nums[mid]]
                break
        return -1

T5:寻找旋转排序数组中的最小值

已知一个长度为 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] ，旋转 4 次得到输入数组。

这道题居然直接让求最小值了，上一道求索引我才客气用哈希，它这样出题那我就直接排序了。

class Solution:
    def findMin(self, nums: List[int]) -> int:
        nums.sort()
        return nums[0]

实测可以通过，我不喜欢研究更好的方法，能过就行。

T6：寻找两个正序数组的中位数

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。

算法的时间复杂度应该为 O(log (m+n)) 。

示例 1：

输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2

示例 2：

输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5

这道题在力扣中还是“困难”题目，但是二分好像并没有难题，对于我来说还不如贪心的中等。

我对这道题的处理方式和T2是一样的，那个是二维列表转一维列表，这个是两个列表合并为一个列表，不过这个合并后需要先排序，然后再处理就简单多了，求一个中位数。

class Solution:
    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
        for i in range(len(nums2)):
            nums1.append(nums2[i])
        nums1.sort()
        left=0
        right=len(nums1)-1
        mid=(left+right)/2
        mid2=(left+right)//2
        print(mid,mid2)
        if mid ==mid2:
            return nums1[mid2]
        else:
            return (nums1[mid2]+nums1[mid2+1])/2
        
        

        本来打算是做贪心中的4道题临时改变了计划，贪心的内容会在明天更新。