二分查找以及大O表示法|Python实现

1. 二分查找简介

不论是学习Python还是学习C语言，甚至是学习Matlab的时候，我都遇到过一个叫“猜数字”的题目。其实，这个问题就是一个查找问题，而解决它的最好办法就是我们都使用过的二分查找。仔细想想，不论是猜数字，还是猜字母，这类游戏的特点就是我们要查找的序列是有序的。在这种有序的序列上应用二分查找可以大大缩短查找时间。

---

2. 二分查找的代码实现

我们首先实现二分查找，

def binary_search(sequence,item):
	'二分查找'

	low = 0
	high = len(sequence) - 1

	while low <= high:
		mid = (low + high) // 2
		guess = sequence[mid]

		if guess == item:
			return mid
		elif guess > item:
			high = mid - 1
		else:
			low = mid + 1

	return None

其中要注意的点是low和high的值，不论是初始值中high的设定或是在循环中更新时的减一操作（否则将在low == high时陷入死循环）。

同时，为了对比二分查找与普通的顺序查找，我们实现顺序查找如下：

def sequential_search(sequence,item):
	'顺序查找'

	low = 0
	high = len(sequence) - 1

	while low <= high:
		guess = sequence[low]

		if guess == item:
			return low
		else:
			low += 1

	return None

---

3. 二分查找与顺序查找的时间对比

我们使用random库随机产生步长从而构造一个有序序列，在其上分别使用二分查找以及顺序查找，使用time库进行简单的对比，同时修改函数使我们能记录查找的次数。

我们用到的函数如下：

import random
import time

def binary_search(sequence,item):
	'二分查找'

	low = 0
	high = len(sequence) - 1
	times = 0

	while low <= high:
		mid = (low + high) // 2
		guess = sequence[mid]
		times += 1

		if guess == item:
			return mid,times
		elif guess > item:
			high = mid - 1
		else:
			low = mid + 1

	return None,times

def sequential_search(sequence,item):
	'顺序查找'

	low = 0
	high = len(sequence) - 1
	times = 0

	while low <= high:
		guess = sequence[low]
		times += 1 

		if guess == item:
			return low,times
		else:
			low += 1

	return None,times

def get_sequence(length):
	'产生序列'

	sequence = [0]

	for i in range(length - 1):
		step = random.randint(1,10)

		sequence.append(sequence[i] + step)

	return sequence

def main(sequence,item):

	start = time.time()
	location,times = binary_search(sequence,item)
	end = time.time()

	print('二分查找时间：{}；次数：{}'.format(end - start,times))

	start = time.time()
	location,times = sequential_search(sequence,item)
	end = time.time()

	print('顺序查找时间：{}；次数：{}\n'.format(end - start,times))

为了增加对比效果，我们将item设置为-1使查找遍历整个序列。

执行具体代码获得结果：

item = -1
sequence_10000 = get_sequence(10000)
main(sequence_10000,item)

sequence_100000 = get_sequence(100000)
main(sequence_100000,item)

sequence_1000000 = get_sequence(1000000)
main(sequence_1000000,item)

具体的结果是

二分查找时间：0.0；次数：13
顺序查找时间：0.0009953975677490234；次数：10000

二分查找时间：0.0；次数：16
顺序查找时间：0.011935234069824219；次数：100000

二分查找时间：0.0；次数：19
顺序查找时间：0.11763334274291992；次数：1000000

可以看到，对于长度分别为10000，100000，1000000的序列，应用二分查找时的时间都可以被忽略，而使用顺序查找时时间几乎按照倍率递增。同时，对于查找次数，二分查找的递增也十分缓慢。

对于顺序查找，我们很容易理解它是线性递增的。下面我们试着讨论二分查找的时间规律。

---

4. 二分查找为什么是对数时间

我们试图寻找二分查找下，查找次数如何随元素个数增加。在顺序查找中，这很明显是线性关系。
首先，我们假设有n个元素，要查找x次。我们只考虑最坏的情况，这样，有

n * 0.5 * 0.5 * 0.5 * ... * 0.5 = 1

这里面共有x个0.5，也就是每查找一次，我们需要考虑的n减小一半，最后减小到1。
这个式子可以写成

n * 0.5^(x) = 1

也就是对数形式的

x = log2(n)

我们发现，这种关系实际上是我们熟悉的对数关系。

当序列有一亿个元素时，我们也只需要最多进行log2(100000000)次查找，即大约27次查询。这告诉我们，在序列长度极大的情况下，我们一定要选择二分查找而不是顺序查找。

我们使用O(操作数)来表示这种关系，那么顺序查找可以表示为O(n)，而二分查找可以表示为O(log n)。这种表示法称为大O表示法。大O表示法永远说的是最糟的情况。这种使用操作数表示的量实际上是我们用来表征算法速度的，但是这个速度指的不是时间，而是随着元素的增加，操作数增长的速度。

下面我们列举五种常见的大O运行时间：

• O(log n)，即对数时间，如上面的二分查找。
• O(n)，即线性时间，如上面的顺序查找。
• O(o * log n)，如快速排序。
• O(n^2)，如选择排序。
• O(n!)，即阶乘时间，如旅行商问题。

它们按照从快到慢的顺序排列，最后一个的运行时间极为漫长（增长极为迅速）。这种阶乘时间一类的算法典型的包括旅行商问题。旅行商问题指的是，一个商人前往五个城市，如何保证这趟旅行的线路最短。这需要我们排列出所有的可能，也就是5 * 4 * 3 * 2 * 1种可能性。这种问题是否存在更好的解决方法是现在仍然需要解决的问题。

---