用python实现归并排序,python中的双斜杠是什么意思

　　序

　　其实Python list的内部实现是数组，也就是线性表。若要在列表中查找元素，请使用list.index(方法)。时间复杂度为o(n)。当有大量数据时，可以通过二分搜索法进行优化。

　　子搜索要求对象必须是有序的，其基本原理如下。

　　1.从数组的中间元素开始。如果中间的元素恰好是你要找的元素，检索过程结束；

　　2.如果一个特定的元素比中间的元素大或者小，就按比中间的元素大或者小的数组的一半来搜索，然后像第一个一样从中间的元素开始比较。

　　3.如果某一步数组为空，说明找不到。

　　二分搜索法也是五五开。每比较一次算法，搜索范围会缩小一半，其时间复杂度为o(logn)。

　　二分搜索法是通过递归和循环实现的：

　　defbinary_search_recursion(lst，value，low，high):

　　如果高/低：

　　不返回

　　mid=(低高)/2

　　如果lst[mid]值：

　　return binary _ search _ recursion(lst，value，low，mid-1))。

　　elif lst[mid]值：

　　return binary _ search _ recursion(lst，value，mid 1，high).

　　否则：

　　放时间

　　defbinary_search_loop(lst，value):

　　低，高=0，len(lst )-1

　　而低=高：

　　mid=(低高)/2

　　如果lst[mid]值：

　　低=中1

　　elif lst[mid]值：

　　高=中间1

　　否则：

　　放时间

　　不返回

　　然后，测试了这两种实现的性能。

　　if __name__==__main__ :

　　随机导入

　　lst=[ random.randint (0，10000 ) for_inxrange ) 100000]

　　lst.sort

　　def test _递归() :

　　binary_search_recursion(lst，999，0，len(lst)-1)))))))))65

　　eftest_loop(:

　　二进制搜索循环(lst，999).

　　导入时间it

　　t1=time it . timer( test _ recursion)，setup= from _ main _ _ import test _ recursion ))

　　T2=timeit.timer(test_loop)，setup= from _ _ main _ import test _ loop))

　　打印“递归：”，t1.timeit(

　　打印“循环：”，t2.timeit(

　　执行结果如下。

　　递归：3.12596702576

　　循环：2.02289628627

　　可见循环模式比递归更高效。

　　平分模块

　　Python二分法模块用于维护有序列表。等分模块实现了将元素插入有序列表的算法。在某些情况下，这比重复排序列表或创建一个大列表进行排序更有效。二等分的意思是二分法，这里用于排序。该元素被插入到有序列表中的适当位置，因此不需要在每次调用排序时维护有序列表。

　　下面显示了的一个简单使用示例。

　　导入位

　　随机导入

　　random.seed(1))。

　　打印“新pos内容”

　　打印-

　　l=[]

　　foriinrange (1，15):

　　r=random.randint (1，100)).

　　position=二等分.二等分(L，r)).

　　insort(L，r)).

　　打印==%(r，position)，l

　　输出结果：

　　新pos内容

　　- - -

　　14 0 [14]

　　81 [ 14,85 ]

　　p77 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]

　　等分模块提供的功能有：

　　二等分.二等分_左(a，x，lo=0，hi=len(a)):

　　求有序列表a中插入x的索引，Lo和hi用于指定列表的区间，默认使用整个列表。如果X已经存在，将它插入到它的左边。返回值是index。

　　二等分.二等分_右(a，x，lo=0，hi=len(a))

　　等分.等分(a，x，lo=0，hi=len(a)):

　　这两个函数类似于平分_左，但是如果x已经存在，就把它插入它的右边。

　　二等分. insort_left(a，x，lo=0，hi=len(a)):

　　在有序列表a中插入X .和a. insert(二分.二分_左(a，X，lo，hi)，X)的作用是一样的。

　　二等分. insort_right(a，x，lo=0，hi=len(a))

　　二等分. insort(a，x，lo=0，hi=len(a)):

　　和向左插入类似，但如果x已经存在，在其右边插入。

　　把…分为两个部分模块提供的函数可以分两类：平分*只用于查找索引，不进行实际的插入；而insort*则用于实际插入。

　　该模块比较典型的应用是计算分数等级：

　　极好的等级（分数，断点=[60,70,80,90],等级=FDCBA ):

　　我=二等分。二等分（断点，得分)

　　返回等级[我]

　　打印[33,99,77,70,89,90,100中分数的等级（分数)]

　　执行结果：

　　[F ， A ， C ， B ， A ， A]

　　同样，我们可以用把…分为两个部分模块实现二分查找：

　　def binary _ search _ bi section(lst，x):

　　从等分导入等分_左

　　我=二等分_左(lst，x)

　　如果我！=len(lst)和lst[i]==x:

　　返回我

　　不返回

　　我们再来测试一下它与递归和循环实现的二分查找的性能：

　　递归：4.00940990448

　　循环：2.653480835

　　二等分：1 .43861 .38386383861

　　可以看到其比循环实现略快，比递归实现差不多要快一半。

　　计算机编程语言著名的数据处理瘦瘦的时光也有一个用于二分查找的函数numpy.searchsorted，用法与把…分为两个部分基本相同，只不过如果要右边插入时，需要设置参数side=右，例如：

　　将数组作为铭牌导入

　　从等分导入左等分，右等分

　　数据=[2,4,7,9]

　　二等分_左（数据，4)

　　一

　　np.searchsorted(data，4)

　　一

　　等分_右（数据，4)

　　2

　　np.searchsorted(data，4，side=right )

　　2

　　那么，我们再来比较一下性能：

　　In [20]: %timeit -n 100等分_左（数据，99999)

　　100次循环，每次循环最好为3: 670纳秒

　　在[21]:% time it-n 100 NP。搜索排序(数据，99999)

　　100次循环，每次循环3分56.9秒

　　在[22]中：%timeit -n 100二等分_左（数据，8888)

　　100次循环，每次循环最好为3分961秒

　　在[23]:% time it-n 100 NP。搜索排序(数据，8888)

　　100次循环，每次循环3分57.6秒

　　在[24]中：%timeit -n 100二等分_左（数据，777777)

　　100次循环，每次循环最好为3: 670纳秒

　　在[25]:% time it-n 100 NP。搜索排序(数据，777777)

　　100次循环，最好成绩为每次循环3: 58.4毫秒

　　可以发现numpy.searchsorted效率是很低的，跟把…分为两个部分根本不在一个数量级上。因此搜索排序不适合用于搜索普通的数组，但是它用来搜索numpy.ndarray是相当快的：

　　在[30]中：data _ ndarray=NP。阿兰格(0.1000000)

　　在[31]:% time它NP。搜索排序(data _ ndarray，99999)

　　最慢的跑比最快的跑花了16.04倍的时间。这可能意味着正在缓存中间结果。

　　1000000个环路，每个环路最好3: 996纳秒

　　在[32]:% time它NP。搜索排序(data _ ndarray，8888)

　　跑得最慢的人比跑得最快的人多花了18.22倍的时间。这可能意味着正在缓存中间结果。

　　1000000个环路，每个环路最好3: 994纳秒

　　在[33]:% time它NP。搜索排序(data _ ndarray，777777)

　　跑得最慢的人比跑得最快的人多花了31.32倍的时间。这可能意味着正在缓存中间结果。

　　1000000个环路，每个环路最好3: 990纳秒

　　numpy.searchsorted可以同时搜索多个值：

　　np.searchsorted([1，2，3，4，5]，3)

　　2

　　np.searchsorted([1，2，3，4，5]，3，side=right )

　　3

　　已排序([1,2,3,4,5],[-10,10,2,3])

　　数组([0,5,1,2])

　　总结

　　以上就是这篇文章的全部内容了，希望本文的内容对大家学习或者使用大蟒能有一定的帮助，如果有疑问大家可以留言交流。

　　本文标题：Python实现二分查找与把…分为两个部分模块详解

　　本文地址：http://www . CPP cns . com/jiao Ben/python/176577 . html

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。