二分查找與 bisect 模塊
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: returnmid 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])
二分查找與 bisect 模塊