一,查找存在的一个数,该数在列表中唯一
二分法查找是针对有序数据的查找方法,时间复杂度是O(logn)。。
其中 n/2^k=1 时,k 的值就是总共缩小的次数。而每一次缩小操作只涉及两个数据的大小比较,所以,
经过了 k 次区间缩小操作,时间复杂度就是 O(k)。通过 n/2^k=1,我们可以求得 k=log2n,所以时间复杂度就是O(K),也就是O(logn)。
方法一,循环
实际上,mid=(low+high)/2 这种写法是有问题的,因为low和high很大的时候,两者之和可能会溢出,应该写为low+(high-low)/2,
更好的话写成,low+((high-low)>>1)
#有序列表的二分法,最简单版
def binary_search(array,value):
if len(array) <= 1:
return array
low=0
high=len(array)-1
while(low<=high):
#多这种写法
mid = low+((high-low)>>1)
if value==array[mid]:
return mid,array[mid]
elif value>array[mid]:
low=mid+1
else:
high=mid-1
return -1,-1
a=[0,1,1.5,2,3,4,9]
index,res=binary_search(a,9)
print('index={},res={}'.format(index,res))
方法二,递归
#有序列表的二分法,最简单版
def binary_search(array,low,high,value):
if low>high:
return -1
mid = low + int((high - low) >> 1)
if value==array[mid]:
return mid,array[mid]
elif value>array[mid]:
low=mid+1
return binary_search(array,low,high,value)
else:
high=mid-1
return binary_search(array, low, high, value)
def binary_search_merge(array,value):
return binary_search(array,0,len(array)-1,value)
a=[0,1,2,3,4,9]
index,res=binary_search_merge(a,9)
print('index={},res={}'.format(index,res))
缺点:(1)依赖的是顺序表结构,比如数组,不能用于链表,(2)需要先排好序,而排序的最低时间复杂度是O(nlogn),(3)不适用于小数据量(4)二分查找更适合处理静态数据,也就是没有频繁的数据插入、删除操作。
二,查找第一个值等于给定值的元素(存在多个值)
target大于目标值,左边界就变大,当找到等于的就返回左边界值,也就是第一个值了
def searchLeft(nums, target):
left, right = 0, len(nums) - 1
while left <= right:
middle = left + (right - left) // 2
if nums[middle] < target:
left = middle + 1
else:
right = middle - 1
return left
nums = [5, 7, 7, 8, 8, 10]
target = 8
# nums = [0, 1, 8, 8, 9, 9, 9]
# target = 9
res = searchLeft(nums, target)
print(res)
三,查找最后一个值等于给定值的元素(存在多个值)
target大于等于左边界的值,这时左边界值越来越大直到找到最后一个才返回
def searchRight(nums, target):
left, right = 0, len(nums) - 1
while left <= right:
middle = left + (right - left) // 2
if nums[middle] <= target: # 加个等于符号 这样left就可以找到最后一个
left = middle + 1
else:
right = middle - 1
return left - 1
nums = [5, 7, 7, 8, 8, 10]
target = 8
# nums = [0, 1, 8, 8, 9, 9, 9]
# target = 9
res = searchRight(nums, target)
print(res)
四,查找第一个大于等于给定值的元素(存在多个值)
#查找第一个大于等于目标值的数
def binary_search(array, value):
left = 0
right = len(array) - 1
while left < right:
middle = left + (right - left)//2
print('====middle:', middle)
if array[middle] < value:
left = middle + 1
else:
right = middle
# print(middle)
return right, array[right]
# a = [0,1,7,7,7,9,9]
a = [0, 1, 1, 1, 1]
index, res = binary_search(a, 1)
print('index={},res={}'.format(index, res))
五. 查找第一个大于给定值的元素(存在多个值)
#查找第一个大于目标值的数
def binary_search(array, value):
left = 0
right = len(array) - 1
while left < right:
middle = left + (right - left)//2
if array[middle] <= value:
left = middle + 1
else:
right = middle
# print(middle)
return right, array[right]
a = [0,1,7,7,7,9,9]
# a = [0, 1, 1, 1, 1]
index, res = binary_search(a, 7)
print('index={},res={}'.format(index, res))
六,查找最后一个小于给定值的元素(存在多个值)
def binary_search(array,value):
if len(array) <= 1:
return array
low=0
high=len(array)-1
while(low<=high):
#多这种写法
mid = low+((high-low)>>1)
#中间值小于value
if array[mid]<value:
#中间值的前一位大于等于value或者mid==len(array)-1
if array[mid+1]>value or mid==len(array)-1:
return mid,array[mid]
else:
low=mid+1
else:
high=mid-1
return -1,-1
a=[0,1,7,7,7,9,9]
index,res=binary_search(a,8)
print('index={},res={}'.format(index,res))
实际上,二分法更适用于‘近似’查找问题,这类问题二分法查找优势更加明显,用其他数据结构比如散列表,二叉树就比较难实现了。
由此引出树:
对于1到11的元素,首先以6为分节点,然后不断分。。。