居合斩！二分查找

参考书籍：《LeetCode 101: A LeetCode Grinding Guide (C++ Version)》

算法解释

• 二分查找：将待查找区间分成两部分并只取一部分继续查找，查找问题中，如果对时间复杂度的要求有 \loglog，通常都需要用到二分查找
• 二分查找的区间左右端的取舍：要不左闭右开（满足C++和Python等语言的习惯），要不左闭右闭（便于处理边界条件），尽量保持一种写法。或根据实际情况考虑极限情况来确定区间端点的取舍，如区间只剩下一个或两个数。
• 二分查找和双指针的区别：二分查找里，指针每次移动半个区间，且一般来说，区间内数据有序；双指针通常是一步一步移动的，区间内数据可能有序可能无序。

练习

1. x 的平方根
   【Leetcode】69. x 的平方根

实现 int sqrt(int x) 函数。

计算并返回 x 的平方根，其中 x 是非负整数。

由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。

示例 1:

输入: 4
输出: 2
示例 2:

输入: 8
输出: 2
说明: 8 的平方根是 2.82842..., 
     由于返回类型是整数，小数部分将被舍去。

class Solution {
public:
    int mySqrt(int x) {
        int low = 1,high = x/2,mid,result;
        if(x<=1) return x;
        while(low <= high){ //这里'<='还是'<'很重要
            mid = low + (high-low)/2; // 注意mid的求法
            result = x/mid;
            if(mid < result) low = mid + 1;
            else if(mid > result) high = mid - 1;
            else return mid;
        }
        return high;
    }
};

用mid=low+(high-low)/2和mid=(low+high)/2两种写法虽然数学上是一样的，但是后者中的加法可能会发生溢出，故用前者最佳
牛顿迭代法：

2. 在排序数组中查找元素的第一个和最后一个位置
   【Leetcode】34

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
如果数组中不存在目标值 target，返回 [-1, -1]。

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int left = leftPoint(nums,target), right = rightPoint(nums,target)-1;
        if(nums.size()==0||left>right||nums[left] != target || nums[right] != target) return vector<int>{-1,-1};
        return vector<int>{left,right};
    }
    int leftPoint(vector<int>& nums, int target){
        int mid,left = 0,right = nums.size();
        while(left<right){
            mid = left+(right-left)/2;  // 只要nums不为空，mid都会在合法范围之内
            if(nums[mid] < target) left = mid+1;
            else right = mid; 
        }
        return left;
    }
    int rightPoint(vector<int>& nums, int target){ 
       int mid,left = 0,right = nums.size();
        while(left<right){
            mid = left+(right-left)/2;
            if(nums[mid] <= target) left = mid+1;
            else right = mid; 
        }
        return right;
    }
};

3. 搜索旋转排序数组
   【Leetcode】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 。
示例 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

来源：力扣（LeetCode）
链接：
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int l = 0, s = nums.size(),mid;
        int r = s-1;
        if(s==0) return -1;
        if(s==1) return (nums[0] == target) ? 0 :-1;
        while(l<=r){
            mid = l + (r-l)/2;
            if(nums[mid]==target) return mid;
            if(nums[0] <= nums[mid]){   //mid的右半部分有序
                if(nums[0] <= target && target <= nums[mid]){
                    r = mid-1;
                }else{
                    l = mid+1;
                }
            }else{
                if(nums[mid] <= target && target <= nums[s-1]){
                    l = mid+1;
                }else{
                    r = mid-1;
                }
            }
        }
        return -1;
    }
};

4. 搜索旋转排序数组 II【Leetcode-81】

已知存在一个按非降序排列的整数数组 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,4,4,5,6,6,7] 在下标 5 处经旋转后可能变为 [4,5,6,6,7,0,1,2,4,4] 。

给你 旋转后 的数组 nums 和一个整数 target ，请你编写一个函数来判断给定的目标值是否存在于数组中。如果 nums 中存在这个目标值 target ，则返回 true ，否则返回 false 。

示例 1：

输入：nums = [2,5,6,0,0,1,2], target = 0
输出：true
示例 2：

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
public:
    bool search(vector<int>& nums, int target) {
        int l = 0, s = nums.size(),mid;
        int r = s-1;
        if(s == 0) return false;
        if(s == 1) return (nums[0]==target)?true:false;
        while(l<=r){
            mid = l + (r-l)/2;
            if(nums[mid]==target) break;
            if(nums[l]==nums[mid])  l++;    //此种情况无法判断那边是有序序列，如[1,0,1,1,1],0
            //先判断有序序列在哪里，然后再看target是在有序序列范围之内还是之外
            else if(nums[mid] > nums[l]){   //注意这里的有序序列左右端点是可变的
                if(nums[l] <= target && target <= nums[mid]) r = mid-1;
                else l = mid+1;
            }else{
                if(nums[mid] <= target && target <= nums[r]) l = mid+1;
                else r = mid-1;
            }
        }
        return (nums[mid]==target)?true:false;
    }
};

5. 【Leetcode 154. 寻找旋转排序数组中的最小值 II】

已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,4,4,5,6,7] 在变化后可能得到：
若旋转 4 次，则可以得到 [4,5,6,7,0,1,4]
若旋转 7 次，则可以得到 [0,1,4,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 ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。
示例 1：
输入：nums = [1,3,5]
输出：1

示例 2：
输入：nums = [2,2,2,0,1]
输出：0

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

python代码

class Solution:
    def findMin(self, nums: List[int]) -> int:
        l = 0
        r = len(nums)-1
        while l < r:
            if nums[l] < nums[r]: return nums[l]
            mid = l + (r-l)//2
            if nums[mid] == nums[r]:
                r -= 1
            elif nums[mid] < nums[r]:    # [mid,r]有序，关键字在[l,mid]
                r = mid
            else:   # [l,mid]有序，关键字在(mid,r]
                l = mid + 1
        return nums[l]

6. 【Leetcode 74. 搜索二维矩阵】

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

示例 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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-a-2d-matrix
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        m = len(matrix)
        n = len(matrix[0])
        if m*n == 0:    return False
        l = 0 
        r = m*n -1
        while(l<=r):	# 注意这里的=
            mid = l + (r-l)//2
            x = mid%n
            y = mid//n
            if matrix[y][x] == target: return True
            elif matrix[y][x] > target: r = mid-1
            else:   l = mid+1
        return False

7. 【Leetcode 540.有序数组中的单一元素】

给定一个只包含整数的有序数组，每个元素都会出现两次，唯有一个数只会出现一次，找出这个数。
示例 1:
输入: nums = [1,1,2,3,3,4,4,8,8]
输出: 2

示例 2:
输入: nums =  [3,3,7,7,10,11,11]
输出: 10

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/single-element-in-a-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution:
    def singleNonDuplicate(self, nums: List[int]) -> int:
        l = 0
        r = len(nums)-1
        while l < r :
            mid = l + (r-l)//2  #注意python这里一定要对2向下取整，不然后面访问nums的小标是float型
            if nums[mid] == nums[mid-1]:
                if ((mid-1)-l)%2 != 0:  # [l,mid-1)中元素个数为奇数，即关键字在该范围内
                    r = mid-2   # 注意这里r = mid-2 ，若r = mid-1，则有可能陷入死循环，如[1,1,2]
                else:   # (mid,r]中元素个数为奇数，即关键字在该范围内
                    l = mid+1
            elif nums[mid] == nums[mid+1]:
                if (r-(mid+1))%2 != 0:  # (mid+1,r]中元素个数为奇数，即关键字在该范围内
                    l = mid+2
                else:   # [l,mid) 中元素个数为奇数，即关键字在该范围内
                    r = mid-1
            else:
                return nums[mid]
        return nums[l]
        

参考链接：二分法变种分析