Pythonは二分検索とbisectモジュールの詳細を実現する
7367 ワード
前言
実はPythonのリスト(list)内部実装は配列、すなわち線形テーブルである.リスト内で要素を検索するには、時間的複雑度がO(n)の
二分検索では、オブジェクトを秩序化する必要があります.その基本原理は次のとおりです.
1.配列の中間要素から始まり、中間要素がちょうど検索する要素であれば、検索プロセスは終了します.
2.特定の要素が中間要素より大きいか小さい場合は、配列が中間要素より大きいか小さいかの半分で検索され、最初と同じように中間要素から比較されます.
3.ステップ配列が空の場合は、見つからないことを意味します.
二分探索も折半探索となり,アルゴリズムは比較するたびに探索範囲を半分に縮小し,その時間複雑度はO(logn)となる.
再帰とループを使用して、2つの検索を実現します.
次に、この2つのインプリメンテーションのパフォーマンステストを行います.
実行結果は次のとおりです.
ループ方式は再帰効率よりも高いことが分かる.
bisectモジュール
Pythonにはbisectモジュールがあり、シーケンステーブルを維持します.bisectモジュールは、エレメントをシーケンステーブルに挿入するアルゴリズムを実現します.場合によっては、リストを並べ替えたり、大きなリストを構築したりして並べ替えるよりも効率的です.Bisectは二分法の意味で、ここでは二分法を使用してソートされ、1つの要素が整列リストの適切な位置に挿入され、sortを呼び出すたびにシーケンステーブルを維持する必要がなくなります.
次に、簡単な使用例を示します.
出力結果:
Bisectモジュールが提供する関数は次のとおりです.
シーケンステーブルaにxを挿入するindexを検索します.loとhiはリストの区間を指定するために使用され、デフォルトではリスト全体が使用されます.xが既に存在する場合は、その左側に挿入します.戻り値はindexです.
この2つの関数とbisect_leftは似ていますが、xがすでに存在する場合は、その右側に挿入します.
シーケンステーブルaにxを挿入します.a.insert(bisect.bisect_left(a,x,lo,hi),x)の効果と同じです.
とinsort_leftは似ていますが、xがすでに存在する場合は、その右側に挿入します.
Bisectモジュールが提供する関数は、bisect*がindexを検索するためにのみ使用され、実際の挿入は行われません.insort*は実際の挿入に使用されます.
このモジュールの比較的典型的な応用はスコア等級を計算することである.
実行結果:
同様にbisectモジュールを使用して二分検索を実現できます.
再帰的およびループ的に実装された二分的検索のパフォーマンスをテストします.
サイクルインプリメンテーションよりもやや速く,再帰インプリメンテーションよりも半分ほど速く見える.
Pythonの有名なデータ処理ライブラリnumpyにも二分検索用の関数
では、パフォーマンスを比較してみましょう.
まとめ
以上がこの文章のすべてですが、本文の内容が皆さんの勉強やpythonの使い方に役立つことを願っています.疑問があれば、伝言を残して交流してください.
実はPythonのリスト(list)内部実装は配列、すなわち線形テーブルである.リスト内で要素を検索するには、時間的複雑度がO(n)の
list.index()
メソッドを使用することができる.ビッグデータ量の場合は、二分検索で最適化できます.二分検索では、オブジェクトを秩序化する必要があります.その基本原理は次のとおりです.
1.配列の中間要素から始まり、中間要素がちょうど検索する要素であれば、検索プロセスは終了します.
2.特定の要素が中間要素より大きいか小さい場合は、配列が中間要素より大きいか小さいかの半分で検索され、最初と同じように中間要素から比較されます.
3.ステップ配列が空の場合は、見つからないことを意味します.
二分探索も折半探索となり,アルゴリズムは比較するたびに探索範囲を半分に縮小し,その時間複雑度はO(logn)となる.
再帰とループを使用して、2つの検索を実現します.
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
次に、この2つのインプリメンテーションのパフォーマンステストを行います.
if __name__ == "__main__":
import random
lst = [random.randint(0, 10000) for _ in xrange(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.12596702576
Loop: 2.08254289627
ループ方式は再帰効率よりも高いことが分かる.
bisectモジュール
Pythonにはbisectモジュールがあり、シーケンステーブルを維持します.bisectモジュールは、エレメントをシーケンステーブルに挿入するアルゴリズムを実現します.場合によっては、リストを並べ替えたり、大きなリストを構築したりして並べ替えるよりも効率的です.Bisectは二分法の意味で、ここでは二分法を使用してソートされ、1つの要素が整列リストの適切な位置に挿入され、sortを呼び出すたびにシーケンステーブルを維持する必要がなくなります.
次に、簡単な使用例を示します.
import bisect
import random
random.seed(1)
print'New Pos Contents'
print'--- --- --------'
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
--- --- --------
14 0 [14]
85 1 [14, 85]
77 1 [14, 77, 85]
26 1 [14, 26, 77, 85]
50 2 [14, 26, 50, 77, 85]
45 2 [14, 26, 45, 50, 77, 85]
66 4 [14, 26, 45, 50, 66, 77, 85]
79 6 [14, 26, 45, 50, 66, 77, 79, 85]
10 0 [10, 14, 26, 45, 50, 66, 77, 79, 85]
3 0 [3, 10, 14, 26, 45, 50, 66, 77, 79, 85]
84 9 [3, 10, 14, 26, 45, 50, 66, 77, 79, 84, 85]
44 4 [3, 10, 14, 26, 44, 45, 50, 66, 77, 79, 84, 85]
77 9 [3, 10, 14, 26, 44, 45, 50, 66, 77, 77, 79, 84, 85]
1 0 [1, 3, 10, 14, 26, 44, 45, 50, 66, 77, 77, 79, 84, 85]
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がすでに存在する場合は、その右側に挿入します.
Bisectモジュールが提供する関数は、bisect*がindexを検索するためにのみ使用され、実際の挿入は行われません.insort*は実際の挿入に使用されます.
このモジュールの比較的典型的な応用はスコア等級を計算することである.
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: 4.00940990448
Loop: 2.6583480835
Bisect: 1.74922895432
サイクルインプリメンテーションよりもやや速く,再帰インプリメンテーションよりも半分ほど速く見える.
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)
1
>>> np.searchsorted(data, 4)
1
>>> bisect_right(data, 4)
2
>>> np.searchsorted(data, 4, side='right')
2
では、パフォーマンスを比較してみましょう.
In [20]: %timeit -n 100 bisect_left(data, 99999)
100 loops, best of 3: 670 ns per loop
In [21]: %timeit -n 100 np.searchsorted(data, 99999)
100 loops, best of 3: 56.9 ms per loop
In [22]: %timeit -n 100 bisect_left(data, 8888)
100 loops, best of 3: 961 ns per loop
In [23]: %timeit -n 100 np.searchsorted(data, 8888)
100 loops, best of 3: 57.6 ms per loop
In [24]: %timeit -n 100 bisect_left(data, 777777)
100 loops, best of 3: 670 ns per loop
In [25]: %timeit -n 100 np.searchsorted(data, 777777)
100 loops, best of 3: 58.4 ms per loop
numpy.searchsorted
は効率が低くbisectとはまったく1桁ではないことが分かった.したがってsearchsortedは通常の配列を検索するのに適していませんが、numpy.ndarray
を検索するのに使用されるのはかなり速いです.
In [30]: data_ndarray = np.arange(0, 1000000)
In [31]: %timeit np.searchsorted(data_ndarray, 99999)
The slowest run took 16.04 times longer than the fastest. This could mean that an intermediate result is being cached.
1000000 loops, best of 3: 996 ns per loop
In [32]: %timeit np.searchsorted(data_ndarray, 8888)
The slowest run took 18.22 times longer than the fastest. This could mean that an intermediate result is being cached.
1000000 loops, best of 3: 994 ns per loop
In [33]: %timeit np.searchsorted(data_ndarray, 777777)
The slowest run took 31.32 times longer than the fastest. This could mean that an intermediate result is being cached.
1000000 loops, best of 3: 990 ns per loop
numpy.searchsorted
は、複数の値を同時に検索できます.
>>> np.searchsorted([1,2,3,4,5], 3)
2
>>> np.searchsorted([1,2,3,4,5], 3, side='right')
3
>>> np.searchsorted([1,2,3,4,5], [-10, 10, 2, 3])
array([0, 5, 1, 2])
まとめ
以上がこの文章のすべてですが、本文の内容が皆さんの勉強やpythonの使い方に役立つことを願っています.疑問があれば、伝言を残して交流してください.