数据结构与算法系列之二分算法
二分查找算法
- 二分查找算法
-
- 二分查找标准算法
- 模版1
- LC题目
-
- lc79
- LC702
-
- 直接遍历+剪枝
- 二分查找
-
- 从题目本身条件出发，创造条件进行二分查找
- 泛化解法，创造条件进行二分查找
二分查找算法
二分法是一种快速查找算法，标准二分查找算法时间复杂度lg(n)。下面我们通过一些例子来进行二分查找算法的解读。
二分查找标准算法
leetcode的704题：
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
作者：力扣 (LeetCode)
链接：https://leetcode-cn.com/leetbook/read/binary-search/xexoac/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
这题是标准的二分查找算法，大家估计都清楚，给定非空有序数组array（假设是升序）与寻找的目标target，主要思路如下：
1、两个指针，左右指针left、right，其中将left指针指向位置0，right指针指向末尾len(array) - 1
2、确定中间指针mid，mid = left + (right - left) / 2
3、然后判断array[mid] 与 target 的大小，有3中情况：
- 相等，此时直接返回mid就好
- 如果 array[mid] > target，说明此时mid所在位置的数比 target 要大，此时，right移动到mid
- 如果 array[mid] < target，说明此时mid所在位置的数比 target 要小，此时，left移动到mid
4、重复以上步骤直到left > right 或者找到target为止
Java代码和Python代码分别如下：
class Solution {
public int search(int[] nums, int target) {
if (nums == null || nums.length == 0)
return -1;
if (nums[0] > target || nums[nums.length -1] < target) {
return -1;
}
int left = 0;
int right = nums.length - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (nums[mid] == target) {
return mid;
}
else if (nums[mid] > target) {
right = mid - 1;
}
else {
left = mid + 1;
}
}
return -1;
}
}
class Solution:
def search(self, nums: List[int], target: int) -> int:
if nums is None or len(nums) == 0:
return -1
if nums[0]>target or nums[-1] < target:
return -1
left, right = 0, len(nums) - 1
while left <= right:
mid = left + (right - left) // 2
if nums[mid] == target:
return mid
elif nums[mid] > target:
right = mid-1
else:
left = mid+1
return -1
模版1
int binarySearch(vector& nums, int target){
if(nums.size() == 0)
return -1;
int left = 0, right = nums.size() - 1;
while(left <= right){
// Prevent (left + right) overflow
int mid = left + (right - left) / 2;
if(nums[mid] == target){ return mid; }
else if(nums[mid] < target) { left = mid + 1; }
else { right = mid - 1; }
}
// End Condition: left > right
return -1;
}
int binarySearch(int[] nums, int target){
if(nums == null || nums.length == 0)
return -1;
int left = 0, right = nums.length - 1;
while(left <= right){
// Prevent (left + right) overflow
int mid = left + (right - left) / 2;
if(nums[mid] == target){ return mid; }
else if(nums[mid] < target) { left = mid + 1; }
else { right = mid - 1; }
}
// End Condition: left > right
return -1;
}
def binarySearch(nums, target):
"""
:type nums: List[int]
:type target: int
:rtype: int
"""
if len(nums) == 0:
return -1
left, right = 0, len(nums) - 1
while left <= right:
mid = (left + right) // 2
if nums[mid] == target:
return mid
elif nums[mid] < target:
left = mid + 1
else:
right = mid - 1
# End Condition: left > right
return -1
LC题目
lc79
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
示例 1:
输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4
示例 2:
输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1
提示：
你可以假设 nums 中的所有元素是不重复的。
n 将在 [1, 10000]之间。
nums 的每个元素都将在 [-9999, 9999]之间。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-search
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
这道题目相对比较简单和基础，直接套用上述模版就好了。
class Solution:
def search(self, nums: List[int], target: int) -> int:
if nums is None or len(nums) == 0:
return -1
left, right = 0, len(nums) - 1
while left <= right:
mid = (left + right) // 2
if nums[mid] == target:
return mid
elif nums[mid] < target:
left = mid + 1
else:
right = mid - 1
return -1
这道题目数组是有限长度了，如果数组是无限长度的呢？
那么请看下一道题。
LC702
给定一个升序整数数组，写一个函数搜索 nums 中数字 target。如果 target 存在，返回它的下标，否则返回 -1。注意，这个数组的大小是未知的。你只可以通过 ArrayReader 接口访问这个数组，ArrayReader.get(k) 返回数组中第 k 个元素（下标从 0 开始）。
你可以认为数组中所有的整数都小于 10000。如果你访问数组越界，ArrayReader.get 会返回 2147483647。
样例 1：
输入: array = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 存在在 nums 中，下标为 4
样例 2：
输入: array = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不在数组中所以返回 -1
注释 ：
你可以认为数组中所有元素的值互不相同。
数组元素的值域是 [-9999, 9999]。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-in-a-sorted-array-of-unknown-size
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
这道题目其实相当于是将有限数组变成了无限长度数组，解题思路类似，如果遍历查找时注意剪枝。
假设一种场景：
如果说，我们要求的目标数不在这个无限数组中，那么可以直接剪枝掉返回-1，否则会一直寻找下去造成超时。
直接遍历+剪枝
时间复杂度O(n)，空间复杂度O(1)
# """
# This is ArrayReader's API interface.
# You should not implement it, or speculate about its implementation
# """
#class ArrayReader:
# def get(self, index: int) -> int:
class Solution:
def search(self, reader, target):
"""
:type reader: ArrayReader
:type target: int
:rtype: int
"""
i = 0
if reader.get(i) == 2147483647:
return -1
while reader.get(i) != target:
if reader.get(i) == 2147483647:
return -1
i += 1
return i
二分查找
这里二分查找的思路相对难找一些，这里总结一下几个方法。
从题目本身条件出发，创造条件进行二分查找
我们知道，二分查找离不开两个条件：一是数组有序，另一个是依据mid与目标值的大小关系来确定左右边界。
目前，数组有序这个条件已经满足了。接下来，需要创造依据mid与目标值的大小关系来确定左右边界的条件。满足这个条件需要有初始边界就好。
该数组是无限数组，如何创造边界呢？题目中有两个假设条件：
注释 ：
- 你可以认为数组中所有元素的值互不相同。
- 数组元素的值域是 [-9999, 9999]。
因此，可以理解成数组的最大长度为 19999（9999*2+1）。
同时，如果越界，数值达到2147483647，超过数组元素最大数值了，因此，即使越界也可以直接进行比较。
然后就可以套用二分模版了，左边界为0，右边界19999（包含），然后开始二分。
# """
# This is ArrayReader's API interface.
# You should not implement it, or speculate about its implementation
# """
#class ArrayReader:
# def get(self, index: int) -> int:
class Solution:
def search(self, reader, target):
"""
:type reader: ArrayReader
:type target: int
:rtype: int
"""
left, right = 0, 19999
if reader.get(0) == 2147483647:
return -1
while left <= right:
mid = left + (right - left) // 2
if reader.get(mid) == target:
return mid
elif reader.get(mid) < target:
left = mid + 1
else:
right = mid-1
return -1
泛化解法，创造条件进行二分查找
由上一条分析，主要是为了创造比较的条件。
那么，无限数组怎么变成有限的呢？可以用区间长度为1的区间（即元素）进行比较，区间为左闭右开区间。
此时，解法更泛化一些，保证数组有序就好了。
这里有两种写法：
# """
# This is ArrayReader's API interface.
# You should not implement it, or speculate about its implementation
# """
#class ArrayReader:
# def get(self, index: int) -> int:
class Solution:
def search(self, reader, target):
"""
:type reader: ArrayReader
:type target: int
:rtype: int
"""
left, right = 0, 1
if reader.get(0) == 2147483647:
return -1
while reader.get(right) < target:
left = right
right = right * 2
while left <= right:
mid = left + (right - left) // 2
if reader.get(mid) == target:
return mid
elif reader.get(mid) < target:
left = left + 1
else:
right = right - 1
return -1
# """
# This is ArrayReader's API interface.
# You should not implement it, or speculate about its implementation
# """
#class ArrayReader:
# def get(self, index: int) -> int:
class Solution:
def search(self, reader, target):
"""
:type reader: ArrayReader
:type target: int
:rtype: int
"""
left, right = 0, 1
if reader.get(0) == 2147483647:
return -1
while left <= right:
mid = left + (right - left) // 2
if reader.get(mid) == target:
return mid
elif reader.get(mid) < target:
left = left + 1
right = right * 2
else:
right = right - 1
return -1