查找
二分查找
15 | 二分查找(上):如何用最省内存的方式实现快速查找功能?
猜数字游戏
一、什么是二分查找?
二分查找针对的是一个有序的数据集合,每次通过跟区间中间的元素对比,将待查找的区间缩小为之前的一半,直到找到要查找的元素,或者区间缩小为0。
二、时间复杂度分析?
1.时间复杂度
假设数据大小是n,每次查找后数据都会缩小为原来的一半,最坏的情况下,直到查找区间被缩小为空,才停止。所以,每次查找的数据大小是:n,n/2,n/4,…,n/(2k),…,这是一个等比数列。当n/(2k)=1时,k的值就是总共缩小的次数,也是查找的总次数。而每次缩小操作只涉及两个数据的大小比较,所以,经过k次区间缩小操作,时间复杂度就是O(k)。通过n/(2^k)=1,可求得k=log2n,所以时间复杂度是O(logn)。
2.认识O(logn)
①这是一种极其高效的时间复杂度,有时甚至比O(1)的算法还要高效。为什么?
②因为logn是一个非常“恐怖“的数量级,即便n非常大,对应的logn也很小。比如n等于2的32次方,也就是42亿,而logn才32。
③由此可见,O(logn)有时就是比O(1000),O(10000)快很多。
三、如何实现二分查找?
1.循环实现
代码实现:
def bin_search(l, n):
# Time: O(log(n))
left = 0
right = len(l) - 1
while left <= right:
mid = left + (right - left) // 2
# mid = left + (right - left)>>2
if n == l[mid]:
return mid
elif n > l[mid]:
left = mid + 1
else:
right = mid - 1
return -1
注意事项:
①循环退出条件是:start<=end,而不是start<end。
②mid的取值,使用mid=start + (end - start) / 2,而不用mid=(start + end)/2,因为如果start和end比较大的话,求和可能会发生int类型的值超出最大范围。为了把性能优化到极致,可以将除以2转换成位运算,即start + ((end - start) >> 1),因为相比除法运算来说,计算机处理位运算要快得多。
③start和end的更新:start = mid - 1,end = mid + 1,若直接写成start = mid,end=mid,就可能会发生死循环。
2.递归实现
def bin_search(l, n):
return _recursion(l, 0, len(l) - 1, n)
def _recursion(l, left, right, n):
if left > right:
return -1
mid = left + (right - left) >> 2
if n == l[mid]:
return mid
elif n > l[mid]:
return _recursion(l, mid+1, right, n)
else:
return _recursion(l, left, mid-1, n)
四、使用条件(应用场景的局限性)
1.二分查找依赖的是顺序表结构,即数组。
2.二分查找针对的是有序数据,因此只能用在插入、删除操作不频繁,一次排序多次查找的场景中。
3.数据量太小不适合二分查找,与直接遍历相比效率提升不明显。但有一个例外,就是数据之间的比较操作非常费时,比如数组中存储的都是长度超过300的字符串,那这是还是尽量减少比较操作使用二分查找吧。
4.数据量太大也不是适合用二分查找,因为数组需要连续的空间,若数据量太大,往往找不到存储如此大规模数据的连续内存空间。
五、内容小结
今天我们学习了一种针对有序数据的高效查找算法,二分查找,它的时间复杂度是 O(logn)。
二分查找的核心思想理解起来非常简单,有点类似分治思想。即每次都通过跟区间中的中间元素对比,将待查找的区间缩小为一半,直到找到要查找的元素,或者区间被缩小为 0。但是二分查找的代码实现比较容易写错。你需要着重掌握它的三个容易出错的地方:循环退出条件、mid 的取值,low 和 high 的更新。
二分查找虽然性能比较优秀,但应用场景也比较有限。底层必须依赖数组,并且还要求数据是有序的。对于较小规模的数据查找,我们直接使用顺序遍历就可以了,二分查找的优势并不明显。二分查找更适合处理静态数据,也就是没有频繁的数据插入、删除操作。
六、思考
1.如何在1000万个整数中快速查找某个整数?每个数据大小是 8 字节
①1000万个整数占用存储空间为80MB,占用空间不大,所以可以全部加载到内存中进行处理;
②用一个1000万个元素的数组存储,然后使用快排进行升序排序,时间复杂度为O(nlogn)
③在有序数组中使用二分查找算法进行查找,时间复杂度为O(logn)
2.如何编程实现“求一个数的平方根”?要求精确到小数点后6位?
3.我刚才说了,如果数据使用链表存储,二分查找的时间复杂就会变得很高,那查找的时间复杂度究竟是多少呢?如果你自己推导一下,你就会深刻地认识到,为何我们会选择用数组而不是链表来实现二分查找了。
假设链表长度为n,二分查找每次都要找到中间点(计算中忽略奇偶数差异):
第一次查找中间点,需要移动指针n/2次;
第二次,需要移动指针n/4次;
第三次需要移动指针n/8次;
…
以此类推,一直到1次为值
总共指针移动次数(查找次数) = n/2 + n/4 + n/8 + …+ 1,这显然是个等比数列,根据等比数列求和公式:Sum = n - 1.
最后算法时间复杂度是:O(n-1),忽略常数,记为O(n),时间复杂度和顺序查找时间复杂度相同
但是稍微思考下,在二分查找的时候,由于要进行多余的运算,严格来说,会比顺序查找时间慢
16 | 二分查找(下):如何快速定位IP对应的省份地址?
变体一:查找第一个值等于给定值的元素
def bsearch1(l, val):
"""
变体一:查找第一个值等于给定值的元素
"""
left = 0
right = len(l) - 1
while left <= right:
mid = left + (right - left) >> 2
if val < l[mid]:
right = mid - 1
elif val > l[mid]:
left = mid + 1
else:
if mid == 0 or l[mid - 1] != val:
return mid
else:
right = mid -1
return -1
变体二:查找最后一个值等于给定值的元素
def bsearch2(l, val):
"""
变体二:查找最后一个值等于给定值的元素
"""
left = 0
right = len(l) - 1
while left <= right:
mid = left + (right - left) >> 2
if val < l[mid]:
right = mid - 1
elif val > l[mid]:
left = mid + 1
else:
if mid == len(l)-1 or l[mid+1] != val:
return mid
else:
left = mid + 1
return -1
变体三:查找第一个大于等于给定值的元素
比如,数组中存储的这样一个序列:3,4,6,7,10。如果查找第一个大于等于 5 的元素,那就是 6。
def bsearch3(l, val):
"""
变体三:查找第一个大于等于给定值的元素
"""
left = 0
right = len(l) - 1
while left <= right:
mid = left + (right - left) >> 2
if l[mid] < val:
left = mid + 1
else:
if mid == 0 or l[mid-1] < val:
return mid
else:
right = mid - 1
return -1
变体四:查找最后一个小于等于给定值的元素
比如,数组中存储了这样一组数据:3,5,6,8,9,10。最后一个小于等于 7 的元素就是 6。
def bsearch4(l, val):
"""
变体四:查找最后一个小于等于给定值的元素
"""
left = 0
right = len(l) - 1
while left <= right:
mid = left + (right - left) >> 2
if l[mid] > val:
right = mid - 1
else:
if mid == len(l)-1 or l[mid+1] > val:
return mid
else:
left = mid + 1
return -1
如何快速定位出一个 IP 地址的归属地?
现在这个问题应该很简单了。如果 IP 区间与归属地的对应关系不经常更新,我们可以先预处理这 12 万条数据,让其按照起始 IP 从小到大排序。如何来排序呢?我们知道,IP 地址可以转化为 32 位的整型数。所以,我们可以将起始地址,按照对应的整型值的大小关系,从小到大进行排序。
然后,这个问题就可以转化为我刚讲的第四种变形问题“在有序数组中,查找最后一个小于等于某个给定值的元素”了。
当我们要查询某个 IP 归属地时,我们可以先通过二分查找,找到最后一个起始 IP 小于等于这个 IP 的 IP 区间,然后,检查这个 IP 是否在这个 IP 区间内,如果在,我们就取出对应的归属地显示;如果不在,就返回未查找到。
内容小结
上一节我说过,凡是用二分查找能解决的,绝大部分我们更倾向于用散列表或者二叉查找树。即便是二分查找在内存使用上更节省,但是毕竟内存如此紧缺的情况并不多。那二分查找真的没什么用处了吗?
实际上,上一节讲的求“值等于给定值”的二分查找确实不怎么会被用到,二分查找更适合用在“近似”查找问题,在这类问题上,二分查找的优势更加明显。比如今天讲的这几种变体问题,用其他数据结构,比如散列表、二叉树,就比较难实现了。
变体的二分查找算法写起来非常烧脑,很容易因为细节处理不好而产生 Bug,这些容易出错的细节有:终止条件、区间上下界更新方法、返回值选择。所以今天的内容你最好能用自己实现一遍,对锻炼编码能力、逻辑思维、写出 Bug free 代码,会很有帮助。
思考:
我们今天讲的都是非常规的二分查找问题,今天的思考题也是一个非常规的二分查找问题。如果有序数组是一个循环有序数组,比如 4,5,6,1,2,3。针对这种情况,如何实现一个求“值等于给定值”的二分查找算法呢?
- 法一
- 找到分界下标,分成两个有序数组
- 判断目标值在哪个有序数据范围内,做二分查找
- 法二
- 找到最大值的下标 x;
- 所有元素下标 +x 偏移,超过数组范围值的取模;
- 利用偏移后的下标做二分查找;
- 如果找到目标下标,再作 -x 偏移,就是目标值实际下标。
两种情况最高时耗都在查找分界点上,所以时间复杂度是 O(N)。
复杂度有点高,能否优化呢?
- 法三
我们发现循环数组存在一个性质:以数组中间点为分区,会将数组分成一个有序数组和一个循环有序数组。
- 如果首元素小于 mid,说明前半部分是有序的,后半部分是循环有序数组;
- 如果首元素大于 mid,说明后半部分是有序的,前半部分是循环有序的数组;
- 如果目标元素在有序数组范围中,使用二分查找;
- 如果目标元素在循环有序数组中,设定数组边界后,使用以上方法继续查找。
时间复杂度为 O(logN)。