Python 的列表（list）内部实现是一个数组，也就是一个线性表。在列表中查找元素可以使用 list.index() 方法，其时间复杂度为O(n)。对于大数据量，则可以用二分查找进行优化。二分查找要求对象必须有序，其基本原理如下：
- 1.从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜素过程结束；
- 2.如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。
- 3.如果在某一步骤数组为空，则代表找不到。
二分查找也成为折半查找，算法每一次比较都使搜索范围缩小一半， 其时间复杂度为 O(logn)。
我们分别用递归和循环来实现二分查找：
def binary_search_recursion(lst, value, low, high):
if high < low:
return None
mid = (low + high)//2
if lst[mid] > value:
return binary_search_recursion(lst, value, low, mid - 1)
elif lst[mid] < value:
return binary_search_recursion(lst, value, mid + 1, high)
else:
return mid
def binary_search_loop(lst, value):
low, high = 0, len(lst) - 1
while low <= high:
mid = (low + high) //2
if lst[mid] < value:
low = mid + 1
elif lst[mid] > value:
high = mid - 1
else:
return mid
return None
接着对这两种实现进行一下性能测试：
if __name__ == "__main__":
import random
lst = [random.randint(0, 10000) for _ in range(100000)]
lst.sort()
def test_recursion():
binary_search_recursion(lst, 999, 0, len(lst) - 1)
def test_loop():
binary_search_loop(lst, 999)
import timeit
t1 = timeit.Timer("test_recursion()", setup="from __main__ import test_recursion")
t2 = timeit.Timer("test_loop()", setup="from __main__ import test_loop")
print("Recursion:", t1.timeit())
print("Loop:", t2.timeit())
执行结果如下：
Recursion: 3.6007582582639275
Loop: 2.6299082704597954
可以看出循环方式比递归效率高。
Python 有一个 bisect 模块，用于维护有序列表。bisect 模块实现了一个算法用于插入元素到有序列表。在一些情况下，这比反复排序列表或构造一个大的列表再排序的效率更高。Bisect 是二分法的意思，这里使用二分法来排序，它会将一个元素插入到一个有序列表的合适位置，这使得不需要每次调用 sort 的方式维护有序列表。
下面是一个简单的使用示例：
import bisect
import random
print(‘New Pos Contents\n--- --- --------‘)
l = []
for i in range(1, 15):
r = random.randint(1, 100)
position = bisect.bisect(l, r)
bisect.insort(l, r)
print(‘%3d %3d‘ % (r, position), l)
输出结果
New Pos Contents --- --- -------- 31 0 [31] 7 0 [7, 31] 54 2 [7, 31, 54] 39 2 [7, 31, 39, 54] 70 4 [7, 31, 39, 54, 70] 63 4 [7, 31, 39, 54, 63, 70] 98 6 [7, 31, 39, 54, 63, 70, 98] 11 1 [7, 11, 31, 39, 54, 63, 70, 98] 84 7 [7, 11, 31, 39, 54, 63, 70, 84, 98] 75 7 [7, 11, 31, 39, 54, 63, 70, 75, 84, 98] 33 3 [7, 11, 31, 33, 39, 54, 63, 70, 75, 84, 98] 2 0 [2, 7, 11, 31, 33, 39, 54, 63, 70, 75, 84, 98] 16 3 [2, 7, 11, 16, 31, 33, 39, 54, 63, 70, 75, 84, 98] 66 9 [2, 7, 11, 16, 31, 33, 39, 54, 63, 66, 70, 75, 84, 98]
Bisect模块提供的函数有：
- bisect.bisect_left(a,x, lo=0, hi=len(a)) :
查找在有序列表 a 中插入 x 的index。lo 和 hi 用于指定列表的区间，默认是使用整个列表。如果 x 已经存在，在其左边插入。返回值为 index。
- bisect.bisect_right(a,x, lo=0, hi=len(a))
- bisect.bisect(a, x,lo=0, hi=len(a)) ：
这2个函数和 bisect_left 类似，但如果 x 已经存在，在其右边插入。
- bisect.insort_left(a,x, lo=0, hi=len(a)) ：
在有序列表 a 中插入 x。和 a.insert(bisect.bisect_left(a,x, lo, hi), x) 的效果相同。
- bisect.insort_right(a,x, lo=0, hi=len(a))
- bisect.insort(a, x,lo=0, hi=len(a)) :
和 insort_left 类似，但如果 x 已经存在，在其右边插入。
def grade(score, breakpoints=[60, 70, 80, 90], grades=‘FDCBA‘):
i = bisect.bisect(breakpoints, score)
return grades[i]
print([grade(score) for score in [33, 99, 77, 70, 89, 90, 100]])
执行结果
[‘F‘, ‘A‘, ‘C‘, ‘C‘, ‘B‘, ‘A‘, ‘A‘]
同样，我们可以用 bisect 模块实现二分查找：
def binary_search_bisect(lst, x):
from bisect import bisect_left
i = bisect_left(lst, x)
if i != len(lst) and lst[i] == x:
return i
return None
执行结果如下
Recursion: 3.6801888509377982 Loop: 2.557316803338421 Bisect 1.7585010485425743
可以看到其比循环实现略快，比递归实现差不多要快一半。
Python 著名的数据处理库 numpy 也有一个用于二分查找的函数 numpy.searchsorted， 用法与 bisect 基本相同，只不过如果要右边插入时，需要设置参数 side=‘right‘，例如：
import numpy as np from bisect import bisect_left, bisect_right data = [2, 4, 7, 9] bisect_left(data, 4) np.searchsorted(data, 4) bisect_right(data, 4) np.searchsorted(data, 4, side=‘right‘)
numpy.searchsorted 效率是很低的，跟 bisect 根本不在一个数量级上。因此 searchsorted 不适合用于搜索普通的数组，但是它用来搜索 numpy.ndarray 是相当快的：
numpy.searchsorted 可以同时搜索多个值：
import numpy as np np.searchsorted([1,2,3,4,5], 3) np.searchsorted([1,2,3,4,5], 3, side=‘right‘) np.searchsorted([1,2,3,4,5], [-10, 10, 2, 3])
原文地址：https://www.cnblogs.com/zxmbky/p/9550572.html