【LeetCode练习|算法通关手册：Python版】03. 数组篇_二分查找
2021.11.23-2021.11.25
Datawhale 11月学习内容；学习地址：https://algo.itcharge.cn/
文章目录
- 1. 二分查找
- 2. 二分下标题目
-
- LeetCode 704. 二分查找
- LeetCode 374. 猜数字大小
- LeetCode 35. 搜索插入位置
- LeetCode 34. 在排序数组中查找元素的第一个和最后一个位置
- LeetCode 167. 两数之和 II - 输入有序数组
- LeetCode 153. 寻找旋转排序数组中的最小值
- Leetcode 154. 寻找旋转排序数组中的最小值 II
- LeetCode 33. 搜索旋转排序数组
- 3. 二分答案题目
-
- LeetCode 69. Sqrt(x)
- LeetCode 287. 寻找重复数
- LeetCode 50. Pow(x, n)
1. 二分查找
基本算法思想：是一种在有序数组中查找某一特定元素的搜索算法。先确定待查找元素所在的区间范围，在逐步缩小范围，直到找到元素或找不到该元素为止。
- 每次查找时从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；
- 如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。
- 如果在某一步骤数组为空，则代表找不到。
事例： 假设原始序列为array=[3, 12, 24, 31, 46, 48, 52, 66, 69, 79, 82]，目标元素target=52。
- 开始时，low=0，high=10，mid=(low + high) / 2 = 5。
- 此时，比目标值小，说明在右侧。
low=5+1=6，high=10，mid=(low + high) / 2 = 8。
- 此时，比目标值大，说明在左侧 low=6，
high=mid-1=7，mid=(low + high) / 2 = 6。
- 就找到了
- 找不到就是，整个数数组找完了（条件：
low > high）都没找到，那说明没有。
代码：
def search(self, nums: List[int], target: int) -> int:
left = 0
right = len(nums) - 1
# 在区间 [left, right] 内查找 target
while left <= right:
# 取区间中间节点
mid = (left + right) // 2
# 如果找到目标值，则直接返回中心位置
if nums[mid] == target:
return mid
# 如果 nums[mid] 小于目标值，则在 [mid + 1, right] 中继续搜索
elif nums[mid] < target:
left = mid + 1
# 如果 nums[mid] 大于目标值，则在 [left, mid - 1] 中继续搜索
else:
right = mid - 1
# 未搜索到元素，返回 -1
return -1
方法二：排除法思想
class Solution:
def search(self, nums: List[int], target: int) -> int:
left = 0
right = len(nums) - 1
# 在区间 [left, right] 内查找 target
while left < right:
# 取区间中间节点
mid = left + (right - left + 1) // 2
# nums[mid] 大于目标值，排除掉不可能区间 [mid, right]，在 [left, mid - 1] 中继续搜索
if nums[mid] > target:
right = mid - 1
# nums[mid] 小于等于目标值，目标元素可能在 [mid, right] 中，在 [mid, right] 中继续搜索
else:
left = mid
# 判断区间剩余元素是否为目标元素，不是则返回 -1
return left if nums[left] == target else -1
if nums[mid] > target:如果中间值大于目标值，那么一定在左半部分- 另一种情况 就是不大于目标值，所以
left = mid - 最终
left=right结束(和while条件相反的临界值) return left if nums[left] == target就是相等的话返回坐标，其他情况返回-1
2. 二分下标题目
LeetCode 704. 二分查找
https://leetcode-cn.com/problems/binary-search/
- 思路没有一点变化，和原理无异
class Solution:
def search(self, nums: List[int], target: int) -> int:
left = 0
right = len(nums)-1
ans = -1
while left <= right:
mid = (left+right)//2
if nums[mid] == target:
ans = mid
return ans
if nums[mid] < target:
left = mid+1
else:
right = mid-1
return ans
LeetCode 374. 猜数字大小
https://leetcode-cn.com/problems/guess-number-higher-or-lower/
- 这道题多少感觉有点问题，以下是答案，如果有看懂的给我讲一下
int guess(int num)来获取猜测结果
class Solution:
def guessNumber(self, n: int) -> int:
left = 1
right = n
while left <= right:
mid = (right + left) // 2
ans = guess(mid)
if ans == 1:
left = mid + 1
elif ans == -1:
right = mid - 1
else:
return mid
return 0
LeetCode 35. 搜索插入位置
https://leetcode-cn.com/problems/search-insert-position/
-
为了效率满足，用了二叉查找，思路没有一点变化，和原理无异
-
唯一不同就是这里要输出插入位置
-
当找到一样值的时候，这个值得位置就是插入的位置
-
如果搜索到最后没找到这个值，也就是结束条件
left > right,一定是应该插入到left这个位置，所以return left
class Solution:
def searchInsert(self, nums: List[int], target: int) -> int:
n = len(nums)
left = 0
right = n - 1
ans = n
while left <= right:
mid = left + (right - left) // 2
if nums[mid] == target:
return mid
elif nums[mid] < target:
left = mid + 1
else:
right = mid - 1
return left
LeetCode 34. 在排序数组中查找元素的第一个和最后一个位置
https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/
这道题如果按正常思路，从小到大找呗，然后找到输出就行。但是本题要求$O(logn)$
思想：
- 用二叉查找发 先找到这个值
- 然后向两边找，直到出现不同
class Solution:
def searchRange(self, nums: List[int], target: int) -> List[int]:
left = 0
right = len(nums) - 1
ans = [-1, -1]
while left <= right:
mid = (left + right) // 2
if nums[mid] == target:
nums.append(0.1)
ans[0] = ans[1] = mid
while (ans[0]-1>=0) and (nums[ans[0]-1] == target) :
ans[0] -= 1
while (nums[ans[1]] == target) and ((ans[1]+1) <= len(nums)-1):
ans[1] += 1
ans[1]= ans[1] -1
return ans
if nums[mid] < target:
left = mid + 1
else:
right = mid - 1
return ans
- 是在二分法相等的条件下做往两端延伸看是否与
target相等。我遇到的问题就是边界的判断 - 当最左端是目标时，如【2,2,3】target =2，因为
nums[-1]是有值的（list最后一个），但我们要防止它套圈,所以加了条件ans[0]-1 >= 0 - 另一个是最右端处理，因为+1 要超出nums长度的，所以我在末尾加了一个不可能出现的数
nums.append(0.1),使得循环不超界 - 最后，我们尝试一下特殊的数组，比如【】，【1】，【2,2】是否满足
参考答案：
class Solution:
def searchRange(self, nums: List[int], target: int) -> List[int]:
ans = [-1, -1]
n = len(nums)
# 空的情况
if n == 0:
return ans
left = 0
right = n - 1
#排除法，最终是要搜索完，那么只有两种情况：没有目标值，和目标值最左端
while left < right:
mid = left + (right - left) // 2
if nums[mid] < target:
left = mid + 1
# 它这个即使现在找到目标值了，但是没有搜索完 还是会去逼近目标值最左端
else:
right = mid
# 没有目标值，返回ans
if nums[left] != target:
return ans
# 存在目标值，那么结束一定是在最左端
ans[0] = left
left = 0
right = n - 1
#同样的方法找最右端
while left < right:
mid = left + (right - left + 1) // 2
if nums[mid] > target:
right = mid - 1
else:
left = mid
if nums[left] == target:
ans[1] = left
return ans
- 这个算法的精彩 在于while循环的排除法，它不是找到结束，而是查完表才结束
- if nums[mid] < target:的
else是nums[mid] >= target,然后让mid成为右端,也就是如果有目标值，那么左端一定存在目标值（右端也可能有） - 循环完
while,最后指针left,right指向同一个地方，只会出现两种情况：① 这个值不是目标值和② 这个值是目标值，且一定是目标值的最左端 - 同理第二个
while找连续目标值的最右端
LeetCode 167. 两数之和 II - 输入有序数组
https://leetcode-cn.com/problems/two-sum-ii-input-array-is-sorted/
条件：
- 有且只有一个有效答案
- 非递减顺序
想法1：
- 双层循环肯定是可以，但效率应该是最低的;
想法2：
- 一层循环+一层二分是可以实现的，效率稍微高一点
- 我采用第一层是
i从小到大的循环，第二层是从left = i+1开始的二分查找
class Solution:
def twoSum(self, numbers: List[int], target: int) -> List[int]:
for i in range(len(numbers)):
#从i+1开始找起
left = i+1
right = len(numbers) - 1
#我们查找的目标值是num
num = target - numbers[i]
while left <= right:
# 取区间中间节点
mid = (left + right) // 2
# 如果找到目标值，则直接返回中心位置
if numbers[mid] == num:
return [i+1, mid+1]
# 如果 nums[mid] 小于目标值，则在 [mid + 1, right] 中继续搜索
elif numbers[mid] < num:
left = mid + 1
# 如果 nums[mid] 大于目标值，则在 [left, mid - 1] 中继续搜索
else:
right = mid - 1
LeetCode 153. 寻找旋转排序数组中的最小值
https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/
思想1：
- 常规思路遍历，找到最小值，输出，但效率低
思想2：
nums[mid] > nums[right]，最小值一定在mid右边nums[mid]<=nums[right]，最小值一定在mid或者mid左边
解析一下：
- 条件是非递减序列，按理说右边至少要和
mid相等或者大的，但现在小了，那么一定是从头开始计算了，也就是起始值在mid右侧
class Solution:
def findMin(self, nums: List[int]) -> int:
left = 0
right = len(nums) - 1
while left < right:
mid = left + (right - left) // 2
if nums[mid] > nums[right]:
left = mid + 1
else:
right = mid
return nums[left]
- 循环结束条件
right = left,若依return nums[right]也行
Leetcode 154. 寻找旋转排序数组中的最小值 II
https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/
条件：
- 与上题不同之处，给你一个可能存在 重复 元素值的数组
nums - 导致我们比右边大小时候，可能无法判断最小值的位置
【3,3,1,3】mid = 1,和右侧比 我们无法判断位置
思想：
- 如果 nums[mid] > nums[right]，则最小值不可能在 mid 左侧，一定在 mid 右侧
- 如果 nums[mid] < nums[right]，则最小值一定在 mid 左侧，
- 当
nums[mid] == nums[right]，无法判断在mid的哪一侧，可以采用right = right - 1逐步缩小区域。
class Solution:
def findMin(self, nums: List[int]) -> int:
left = 0
right = len(nums) - 1
while left < right:
mid = left + (right - left) // 2
if nums[mid] > nums[right]:
left = mid + 1
elif nums[mid] < nums[right]:
right = mid
else:
right = right - 1
return nums[left]
LeetCode 33. 搜索旋转排序数组
https://leetcode-cn.com/problems/search-in-rotated-sorted-array/
条件：
- 互不相同
- 升序排列
想法：
思想就是看mid两边哪边是连续的，再判断target是否在连续这端取值，如果是，那再进行二分
示例 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
mid = (0 + 6) // 2 == 3, 此时nums[mid] == 7，下面开始判断。
-
如果 nums[left] == nums[mid]:，返回
mid -
如果 nums[left] <= nums[mid]: 左侧是连续增大的，没有断层
① 当
nums[left] <= target < nums[mid]，那么如果有答案，就在这之间right = mid - 1②如果不是上一种情况 那么又在mid右侧，缩减
left = mid + 1 -
如果nums[left] > nums[mid]，那么右侧是连续的
①
nums[mid] < target <= nums[right],此时我们缩减left += 1②否则，缩减
right = mid - 1
class Solution:
def search(self, nums, target):
left, right = 0, len(nums) - 1
while left <= right:
mid = (left + right) // 2
if nums[mid] == target:
return mid
elif nums[left] <= nums[mid]:
if nums[left] <= target < nums[mid]:
right = mid - 1
else:
left = mid + 1
else:
if nums[mid] < target <= nums[right]:
left = mid + 1
else:
right = mid - 1
return -1
难点：
-
while left <= right为什么要有=号?因为我们相等的时候还需要判断，这个mid的情况，也就是存在不一定的存在的情况，所以要判断完才能结束。
-
elif nums[left] <= nums[mid]:为什么要有=号?边界问题，我们重点看的是哪些地方连续。
如果条件是：
nums[left] < nums[mid],比如【3,1】，target =1 那么我们mid =0 我们认为左边不连续，是右边连续，右边是个1<3，(连续的话一定是nums[right] >= nums[mid]) 所以它认为找不到，输出了-1,就错过了正确答案。
3. 二分答案题目
LeetCode 69. Sqrt(x)
https://leetcode-cn.com/problems/sqrtx/
常规想法超时：
- 也就是 我用个
i,然后看i**2 <=x and (i+1)**2 >x
class Solution:
def mySqrt(self, x: int) -> int:
if x == 1:
return 1
for i in range(1,x//2+1):
if (i**2 <= x) and ((i+1)**2>x):
return i
return 0
改进，用二分法：
class Solution:
def mySqrt(self, x: int) -> int:
left = 0
right = x
ans = -1
while left <= right:
mid = (left+right)//2
if mid*mid <= x:
ans = mid
left = mid+1
else:
right = mid-1
return ans
LeetCode 287. 寻找重复数
https://leetcode-cn.com/problems/find-the-duplicate-number/
条件：
- 不能修改数组
nums,也就是不能排序 - 只用
O(1)额外空间 - 里边包含的值都在 1~n 之间，且有且只有一个重复的
想法：
-
限制条件很多 如果没有重复 那么
n+1个数有n+1个不重复的 -
现在只有一个不重复的 那么本来 比
n小的有1到n-1也就n-1个值 -
有效范围
[left..right]里位于中间的数mid，然后统计原始数组中 小于等于mid的元素的个数cnt：① 果
cnt严格大于mid。根据抽屉原理，重复元素就在区间[left..mid]里② 否则，重复元素就在区间
[mid + 1..right]里。
class Solution:
def findDuplicate(self, nums: List[int]) -> int:
n = len(nums)
left = 1
right = n - 1
while left < right:
mid = left + (right - left) // 2
cnt = 0
for num in nums:
# 实际上不比mid大的
if num <= mid:
cnt += 1
# 如果实际上确实不比mid大，那么不在左侧
if cnt <= mid:
left = mid + 1
# 那么如果这个是值大于mid 那么一定在mid左侧
else:
right = mid
return left
理解：
- mid = 3 说的是中间的数字，而不是座位号（因为
left从1起的），那么整个数组里不大于3的应该就1,2,3三个 - 换句话说，也就是
cnt:取的实际上不比mid大的
LeetCode 50. Pow(x, n)
https://leetcode-cn.com/problems/powx-n/
思想：
-
我们要处理一下
n<0的情况 -
传统应该
x乘以n次，这里通过折半查找，来降低时间复杂度如果 n是2的倍数 那么底数可以是
x**2,指数减半
class Solution:
def myPow(self, x: float, n: int) -> float:
res = 1
if n < 0:
x,n = 1/x,-n
while n: # 通过折半计算，每次把 n 减半，降低时间复杂度
if n%2 == 0:
x *= x
n /= 2
else:
res *=x
n -= 1
return res
