algorithm - 二分查找

简介

---

       当我们要从一个序列中查找一个元素的时候，二分查找是一种非常快速的查找算法，二分查找又叫二分搜索或折半查找。
       二分查找的思想非常简单，有点类似分治的思想。二分查找针对的是一个有序的数据集合，每次都通过跟区间的中间元素对比，将待查找的区间缩小为之前的一半，直到找到要查找的元素，或者区间被缩小为 0。

       它对要查找的序列有两个要求：一是该序列必须是有序的（即该序列中的所有元素都是按照大小关系排好序的，升序和降序都可以，本文假设是升序排列的）；二是该序列必须是顺序存储的。

算法原理

---

二分查找算法的原理如下：

1. 如果待查序列为空，那么就返回-1，并退出算法；这表示查找不到目标元素。

2. 如果待查序列不为空，则将它的中间元素与要查找的目标元素进行匹配，看它们是否相等。

3. 如果相等，则返回该中间元素的索引，并退出算法；此时就查找成功了。

4. 如果不相等，就再比较这两个元素的大小。

5. 如果该中间元素大于目标元素，那么就将当前序列的前半部分作为新的待查序列；这是因为后半部分的所有元素都大于目标元素，它们全都被排除了。

6. 如果该中间元素小于目标元素，那么就将当前序列的后半部分作为新的待查序列；这是因为前半部分的所有元素都小于目标元素，它们全都被排除了。

7. 在新的待查序列上重新开始第1步的工作。

二分查找之所以快速，是因为它在匹配不成功的时候，每次都能排除剩余元素中一半的元素。因此可能包含目标元素的有效范围就收缩得很快，而不像顺序查找那样，每次仅能排除一个元素。

下面来看一张二分查找与顺序查找的效率对比图：

 

算法复杂度

---

（1）时间复杂度

       在最好的情况下只需要进行1次比较就能找到目标元素。
       那么最坏的情况呢？此时可以借助该序列的二叉树形式进行分析。将一个序列转换为二叉树的过程是这样的：将它的中间元素作为它的根节点，将中间元素之前的前半部分作为它的左子树，将中间元素之后的后半部分作为它的右子树；在创建左子树和右子树的时候递归利用这一规则。

       以序列[5, 10, 22, 29, 43, 57, 58, 61, 73, 77, 81]为例，可以构建成如图所示的二叉树：

（2）空间复杂度

       在下面的实现中，二分查找对于存储空间的要求是只需要能存储left、right、mid、target、index、数组地址（参数nums）这6个局部变量就行了，因此它对存储空间的要求是常数数量，不随着元素多少而变化。所以它的空间复杂度为O(1)。

局限性

---

（1）二分查找依赖数组结构

       二分查找需要利用下标随机访问元素，如果我们想使用链表等其他数据结构则无法实现二分查找。

（2）二分查找针对的是有序数据

       二分查找需要的数据必须是有序的。如果数据没有序，我们需要先排序，排序的时间复杂度最低是 O(nlogn)。所以，如果我们针对的是一组静态的数据，没有频繁地插入、删除，我们可以进行一次排序，多次二分查找。这样排序的成本可被均摊，二分查找的边际成本就会比较低。

       但是，如果我们的数据集合有频繁的插入和删除操作，要想用二分查找，要么每次插入、删除操作之后保证数据仍然有序，要么在每次二分查找之前都先进行排序。针对这种动态数据集合，无论哪种方法，维护有序的成本都是很高的。

       所以，二分查找只能用在插入、删除操作不频繁，一次排序多次查找的场景中。针对动态变化的数据集合，二分查找将不再适用

（3）数据量太小不适合二分查找

       如果要处理的数据量很小，完全没有必要用二分查找，顺序遍历就足够了。比如我们在一个大小为 10 的数组中查找一个元素，不管用二分查找还是顺序遍历，查找速度都差不多，只有数据量比较大的时候，二分查找的优势才会比较明显。

（4）数据量太大不适合二分查找

       二分查找底层依赖的是数组，数组需要的是一段连续的存储空间，所以我们的数据比较大时，比如1GB，这时候可能不太适合使用二分查找，因为我们的内存都是离散的，可能电脑没有这么多的内存。

算法实现

---

常见的二分查找算法共有三种形态：
       ①寻找序列中目标值的索引

       ②寻找序列中目标值第一次出现位置的索引

       ③寻找序列中目标值最后一次出现位置的索引

下面就使用go语言为例，对其分别进行实现：

// 描述
// 请实现无重复数字的升序数组的二分查找
// 给定一个 元素有序的（升序）整型数组 nums 和一个目标值 target  ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1

func binarySearch_mormal(nums []int, target int) int {
	var left, right int = 0, len(nums)-1
	for left <= right {
		mid := left + ((right - left) >> 1)
		if (nums[mid] == target) {
			return mid
		} else if (nums[mid] > target) {
			right = mid - 1
		} else {
			left = mid + 1
		}
	}
	return -1
}


/// 递归实现
func recursiveBinarySerach(nums []int, left, right, target int) int {
	if (left > right) {
		return -1
	}
	mid := left + ((right - left) >> 1)
	if (nums[mid] == target) {
		return mid
	} else if (nums[mid] > target) {
		return recursiveBinarySerach(nums, left, mid - 1, target)
	} else {
		return recursiveBinarySerach(nums, mid + 1, right, target)
	}
}

// 描述
// 请实现有重复数字的升序数组的二分查找
// 给定一个 元素有序的（升序）整型数组 nums 和一个目标值 target  ，写一个函数搜索 nums 中的第一个出现的target，如果目标值存在返回下标，否则返回 -1

func binarySearch_leftBorder(nums []int, target int) int {
	var index, left, right int = -1, 0, len(nums)-1
	for left <= right {
		mid := left + ((right - left) >> 1)
		if (nums[mid] == target) {
			index = mid
			right = mid - 1
		} else if (nums[mid] > target) {
			right = mid - 1
		} else {
			left = mid + 1
		}
	}
	return index
}

// 描述
// 请实现有重复数字的升序数组的二分查找
// 给定一个 元素有序的（升序）整型数组 nums 和一个目标值 target  ，写一个函数搜索 nums 中的最后一个出现的target，如果目标值存在返回下标，否则返回 -1

func binarySearch_rightBorder(nums []int, target int) int {
	var index, left, right int = -1, 0, len(nums)-1
	for left <= right {
		mid := left + ((right - left) >> 1)
		if (nums[mid] == target) {
			index = mid
			left = mid + 1
		} else if (nums[mid] > target) {
			right = mid - 1
		} else {
			left = mid + 1
		}
	}
	return index
}

参考博文

---

http://03ozy.cn/iA3rM
http://3bwpf.cn/FT8CB