TOP100 二分法

写在前面：二分法用在有序序列上

1.35. 搜索插入位置

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

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

示例 1:

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

示例 2:

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

示例 3:

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

提示:

• 1 <= nums.length <= 10^4
• -10^4 <= nums[i] <= 10^4
• nums 为 无重复元素 的 升序 排列数组
• -10^4 <= target <= 10^4

思路：

查找元素，又必须是lgn的复杂度，肯定是二分了。

其实二分法有两种写法，最主要的就是要分清楚不变量，或者说主要就在于如何去判断边界。

下面借卡哥的讲法介绍给大家：
1)判断边界为左闭右闭，此时while(left<=right)，当nums[middle]>key时，需要将right=middle-1;因为middle在本循环中是要计算进的，当前这个middle肯定不是key值。

2）如果说定义 target 是在一个在左闭右开的区间里，也就是[left, right) ，那么二分法的边界处理方式则截然不同。
有如下两点：

• while (left < right)，这里使用 < ,因为left == right在区间[left, right)是没有意义的
• if (nums[middle] > target) right 更新为 middle，因为当前nums[middle]不等于target，去左区间继续寻找，而寻找区间是左闭右开区间，所以right更新为middle，即：下一个查询区间不会去比较nums[middle]

【摘自：代码随想录 (programmercarl.com)】

代码：

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

思考：

通过AC发现了，当不存在该元素时，该元素所在位置为right+1。

2.74. 搜索二维矩阵

给你一个满足下述两条属性的 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

提示：

• m == matrix.length
• n == matrix[i].length
• 1 <= m, n <= 100
• -10^4 <= matrix[i][j], target <= 10^4

思路：

由于二维矩阵固定列的「从上到下」或者固定行的「从左到右」都是升序的。

因此我们可以使用两次二分来定位到目标位置：

第一次二分：从第 0 列中的「所有行」开始找，找到合适的行 row

第二次二分：从 row 中「所有列」开始找，找到合适的列 col

代码：java

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        int m = matrix.length, n = matrix[0].length;

        // 第一次二分：定位到所在行（从上往下，找到最后一个满足 matrix[x]][0] <= t 的行号）
        int l=0,r=m-1;
        while(l<r){
            int mid=l+r+1 >> 1;
            if(matrix[mid][0]<=target){
                l=mid;
            }else{
                r=mid-1;
            }
        }
        int row = r;
        if(matrix[row][0]==target)return true;
        if(matrix[row][0]>target)return false;
        //第二次二分
        l=0;r=n-1;
        while(l<r){
            int mid=l + r + 1 >> 1;
            if(matrix[row][mid]<=target){
                l=mid;
            }else{
                r=mid-1;
            }
        }
        int col =r;
        return matrix[row][col] == target;
    }
}

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

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

示例 3：

输入：nums = [], target = 0
输出：[-1,-1]

提示：

• 0 <= nums.length <= 10^5
• -10^9 <= nums[i] <= 10^9
• nums 是一个非递减数组
• -10^9 <= target <= 10^9

思路：

1.第一种想法：

边界不要想太多，就两段二分查找就好，不要找到一个mid后再循环左右移动下标，这样时间复杂度在一些情况下会退化为O(N)

2.第二种想法：

考虑 target开始和结束位置，其实我们要找的就是数组中「第一个等于 target的位置」（记为 leftIdx）和「第一个大于 target的位置减一」（记为 rightIdx）。

代码：

第一种:python

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        def search(self,nums:List[int],target:int,left:int,right:int,lower:bool):
            res=-1
            while left<=right:
                mid=(left+right)//2
                if nums[mid]<target:
                    left=mid+1
                elif nums[mid]>target:
                    right=mid-1
                elif nums[mid]==target and lower:
                    res = mid
                    right=mid-1
                elif nums[mid]==target:
                    res=mid
                    left=mid+1
            return res

        n=len(nums)
        left,right=0,n-1
        res=[]
        res.append(search(self,nums,target,left,right,True))
        if res[0]==-1:
            return [-1,-1]
        res.append(search(self,nums,target,left,right,False))
        return res

    

第二种：

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int leftIdx = binarySearch(nums, target, true);
        int rightIdx = binarySearch(nums, target, false) - 1;
        if (leftIdx <= rightIdx && rightIdx < nums.length && nums[leftIdx] == target && nums[rightIdx] == target) {
            return new int[]{leftIdx, rightIdx};
        } 
        return new int[]{-1, -1};
    }

    public int binarySearch(int[] nums, int target, boolean lower) {
        int left = 0, right = nums.length - 1, ans = nums.length;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (nums[mid] > target || (lower && nums[mid] >= target)) {
                right = mid - 1;
                ans = mid;
            } else {
                left = mid + 1;
            }
        }
        return ans;
    }
}

4.33. 搜索旋转排序数组

整数数组 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

示例 3：

输入：nums = [1], target = 0
输出：-1

提示：

• 1 <= nums.length <= 5000
• -10^4 <= nums[i] <= 10^4
• nums 中的每个值都 独一无二
• 题目数据保证 nums 在预先未知的某个下标上进行了旋转
• -10^4 <= target <= 10^4

思路：

首先寻找旋转点的序号，设为W,然后直接将其旋转复原（使用列表的切片方法），旋转后就是正常的非递减序列，然后进行二分查找，找到后按照以下图解，可知，需要对现有序号做一个映射！

具体映射转换关系，见代码！

代码：

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        warn=0
        n=len(nums)
        i=1
        while i <= n-1:#寻找旋转点的序号，[4,5,6,1,2,3]即warn=3
            if nums[i]<nums[i-1]:
                start=nums[i:]
                warn=i
                nums=start+nums[:i]
                # print(nums)
                break
            i+=1
        left,right=0,len(nums)-1
        res=-1
        while left <= right:#正常有序情况下的二分，查出来的顺序，应该要进行映射
            mid = left+(right-left)//2
            if nums[mid]>target:
                right=mid-1
            elif nums[mid]<target:
                left=mid+1
            else:
                res=mid
                # print(res)
                break
        if res==-1:
            # print(".."+str(res))
            return res
        if res < n-warn:#如果位置(下标)在旋转的前半段上，也就是小于n-warn
            return res+warn
        else:#否则就在后半段，那么就应该将res-warn，也就是前移warn位(错了)，应该是移动(n-warn)位
            return res-n+warn

5.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]

注意，数组 [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] ，旋转 3 次得到输入数组。

示例 3：

输入：nums = [11,13,15,17]
输出：11
解释：原数组为 [11,13,15,17] ，旋转 4 次得到输入数组。

提示：

• n == nums.length
• 1 <= n <= 5000
• -5000 <= nums[i] <= 5000
• nums 中的所有整数 互不相同
• nums 原来是一个升序排序的数组，并进行了 1 至 n 次旋转

思路：

代码：

6.4. 寻找两个正序数组的中位数

给定两个大小分别为 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

思路：

代码：