算法学习（五）

学习内容：

二分法：每次搜索时通过将搜索区间分成两部分并只取一部分搜索，将搜索的复杂度减少，对于一个为n长度的区间，时间复杂度为O（logn）

学习产出：

求开方、搜索区间、旋转数组

求开方

LeetCode 69 x 的平方根

实现 int sqrt(int x) 函数。

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

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

示例 1:

输入: 4
输出: 2

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

题解

把题想象成一元二次方程求解，$f(x)=x^2-a=0，且x>=0$ 的解，所以 $f(x)$在定义域上是单调递增，考虑到$f(0)=-a<0,f(a)=a^2-a>0$ ,因此考虑区间为 [0,a]，对 [0,a] 区间使用二分法查找$f(x)=0$ 的解

步骤：

1. 初始化左右区间
2. 二分取区间中间数
3. 中间大于，则取小的左部分；中间小于，则取大的右部分
4. 重复第 2 和第 3 步，直到得到结果

代码（python）

class Solution:
    def mySqrt(self, x: int) -> int:
    	if x == 0: return 0
    	l,r = 0,x #初始化区间[l,r]
    	while l <= r :
    		mid = (l+r)/2  #二分区间
    		if x < mid * mid:  #中间大于，则取小的左部分
    			r = mid - 1
    		elif x > mid * mid: #中间小于，则取大的右部分
    			l = mid + 1
    		else:
    			return mid
    	return r

其实可以考虑牛顿迭代法，更为简单（不详细介绍了）

class Solution:
    def mySqrt(self, x: int) -> int:
    	a = x
    	while a * a > x:
    		x = (x+a/x)/2
    	return x

搜索区间

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

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

进阶：

你可以设计并实现时间复杂度为 O(log n) 的算法解决此问题吗？

示例 1：

输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]

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

题解

二分查找，搜索重复数字的左右边界。

步骤：

1. 初始化左右区间
2. 二分取区间中间数
3. 搜索左区间
4. 重复第 2 和第 3 步，搜索右区间，直到得到结果

代码（python）

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        # 二分查找，搜索左右边界
        if not nums:
            return [-1, -1]
        return [self.search_left(nums, target), self.search_right(nums, target)]

    def search_left(self, nums, target): #搜索左边界
        l, r = 0, len(nums) - 1
        while l <= r:
            mid = l + (r - l) // 2
            if nums[mid] > target:
                r = mid - 1
            elif nums[mid] < target:
                l = mid + 1
            elif nums[mid] == target:
                r = mid - 1        # 使搜索区间向左侧收缩
        if l >= len(nums) or nums[l] != target:   # 判断索引越界情况
            return -1
        return l

    def search_right(self, nums, target): #搜素右边界
        l, r = 0, len(nums) - 1
        while l <= r:
            mid = l + (r - l) // 2
            if nums[mid] > target:
                r = mid - 1
            elif nums[mid] < target:
                l = mid + 1
            elif nums[mid] == target:
                l = mid + 1        # 使搜索区间向右侧收缩
        if r < 0 or nums[r] != target:   # 判断索引越界情况
            return -1                                   
        return r

python内置函数index能实现，复杂度O(1) ，反转列表O(n)

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        if target not in nums:return [-1,-1]
        i = nums.index(target)
        j = len(nums)-nums[::-1].index(target)
        return [i,j-1]
            

旋转数组

LeetCode 81 搜索旋转排序数组 II

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,0,1,2,2,5,6] 可能变为 [2,5,6,0,0,1,2] )。

编写一个函数来判断给定的目标值是否存在于数组中。若存在返回 true，否则返回 false。

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

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

题解

数组被旋转过，仍然借助数组的递增性，利用二分法取中点，当中点小于等于右端，则说明右区间排好序；否则，左区间排好序。如果目标值位于排好序的区间内，则用二分法查找；否则，对另一区间查找。
注意：如果出现重复数据，则往左端点右移一位

步骤：

1. 初始化左右区间
2. 二分取区间中间数
3. 搜索左区间
4. 重复第 2 和第 3 步，搜索右区间，直到得到结果

代码（python）

class Solution:
    def search(self, nums: List[int], target: int) -> bool:
        l,r = 0,len(nums)-1
        while l <= r:
        	mid = (l + r) // 2
        	if nums[mid] == target : return True
        	if nums[l] == nums[mid] :  #无法判断哪个区间是增序的
        		l+=1
        	elif nums[mid] <= nums[r]: #右区间增序
        		if target > nums[mid] and target <= nums[r]:  #二分法
        			l = mid + 1
        		else:
        			r = mid - 1
        	else: #左区间增序
        		if target >= nums[l] and target <= nums[mid]:  #二分法
        			r = mid - 1
        		else:
        			l = mid + 1
        return False  		
            		

python内置函数index能更为简单实现，复杂度O(1)

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        try:
            nums.index(target)
            return True
        except:
            return False